1 //===--- Tools.cpp - Tools Implementations ------------------------------*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 #include "clang/Driver/Action.h"
13 #include "clang/Driver/Arg.h"
14 #include "clang/Driver/ArgList.h"
15 #include "clang/Driver/Driver.h" // FIXME: Remove?
16 #include "clang/Driver/DriverDiagnostic.h" // FIXME: Remove?
17 #include "clang/Driver/Compilation.h"
18 #include "clang/Driver/Job.h"
19 #include "clang/Driver/HostInfo.h"
20 #include "clang/Driver/Option.h"
21 #include "clang/Driver/ToolChain.h"
22 #include "clang/Driver/Util.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/Support/Format.h"
26 #include "llvm/Support/raw_ostream.h"
28 #include "InputInfo.h"
29 #include "ToolChains.h"
31 using namespace clang::driver
;
32 using namespace clang::driver::tools
;
34 static const char *MakeFormattedString(const ArgList
&Args
,
35 const llvm::format_object_base
&Fmt
) {
37 llvm::raw_string_ostream(Str
) << Fmt
;
38 return Args
.MakeArgString(Str
.c_str());
41 void Clang::AddPreprocessingOptions(const Driver
&D
,
43 ArgStringList
&CmdArgs
,
44 const InputInfo
&Output
,
45 const InputInfoList
&Inputs
) const {
48 if ((A
= Args
.getLastArg(options::OPT_C
)) ||
49 (A
= Args
.getLastArg(options::OPT_CC
))) {
50 if (!Args
.hasArg(options::OPT_E
))
51 D
.Diag(clang::diag::err_drv_argument_only_allowed_with
)
52 << A
->getAsString(Args
) << "-E";
53 A
->render(Args
, CmdArgs
);
56 // Handle dependency file generation.
57 if ((A
= Args
.getLastArg(options::OPT_M
)) ||
58 (A
= Args
.getLastArg(options::OPT_MM
)) ||
59 (A
= Args
.getLastArg(options::OPT_MD
)) ||
60 (A
= Args
.getLastArg(options::OPT_MMD
))) {
61 // Determine the output location.
63 if (Output
.getType() == types::TY_Dependencies
) {
67 DepFile
= Output
.getFilename();
68 } else if (Arg
*MF
= Args
.getLastArg(options::OPT_MF
)) {
69 DepFile
= MF
->getValue(Args
);
70 } else if (A
->getOption().getId() == options::OPT_M
||
71 A
->getOption().getId() == options::OPT_MM
) {
74 DepFile
= darwin::CC1::getDependencyFileName(Args
, Inputs
);
76 CmdArgs
.push_back("-dependency-file");
77 CmdArgs
.push_back(DepFile
);
79 // Add an -MT option if the user didn't specify their own.
80 // FIXME: This should use -MQ, when we support it.
81 if (!Args
.hasArg(options::OPT_MT
) && !Args
.hasArg(options::OPT_MQ
)) {
82 const char *DepTarget
;
84 // If user provided -o, that is the dependency target, except
85 // when we are only generating a dependency file.
86 Arg
*OutputOpt
= Args
.getLastArg(options::OPT_o
);
87 if (OutputOpt
&& Output
.getType() != types::TY_Dependencies
) {
88 DepTarget
= OutputOpt
->getValue(Args
);
90 // Otherwise derive from the base input.
92 // FIXME: This should use the computed output file location.
93 llvm::sys::Path
P(Inputs
[0].getBaseInput());
97 DepTarget
= Args
.MakeArgString(P
.getLast().c_str());
100 CmdArgs
.push_back("-MT");
101 CmdArgs
.push_back(DepTarget
);
104 if (A
->getOption().getId() == options::OPT_M
||
105 A
->getOption().getId() == options::OPT_MD
)
106 CmdArgs
.push_back("-sys-header-deps");
109 Args
.AddLastArg(CmdArgs
, options::OPT_MP
);
110 Args
.AddAllArgs(CmdArgs
, options::OPT_MT
);
112 // FIXME: Use iterator.
114 // Add -i* options, and automatically translate to
115 // -include-pch/-include-pth for transparent PCH support. It's
116 // wonky, but we include looking for .gch so we can support seamless
117 // replacement into a build system already set up to be generating
119 for (ArgList::const_iterator
120 it
= Args
.begin(), ie
= Args
.end(); it
!= ie
; ++it
) {
122 if (!A
->getOption().matches(options::OPT_clang_i_Group
))
125 if (A
->getOption().matches(options::OPT_include
)) {
126 bool FoundPTH
= false;
127 bool FoundPCH
= false;
128 llvm::sys::Path
P(A
->getValue(Args
));
130 P
.appendSuffix("pch");
138 P
.appendSuffix("pth");
145 if (!FoundPCH
&& !FoundPTH
) {
146 P
.appendSuffix("gch");
148 FoundPCH
= D
.CCCUsePCH
;
149 FoundPTH
= !D
.CCCUsePCH
;
155 if (FoundPCH
|| FoundPTH
) {
158 CmdArgs
.push_back("-include-pch");
160 CmdArgs
.push_back("-include-pth");
161 CmdArgs
.push_back(Args
.MakeArgString(P
.c_str()));
166 // Not translated, render as usual.
168 A
->render(Args
, CmdArgs
);
171 Args
.AddAllArgs(CmdArgs
, options::OPT_D
, options::OPT_U
);
172 Args
.AddAllArgs(CmdArgs
, options::OPT_I_Group
, options::OPT_F
);
174 // Add -Wp, and -Xassembler if using the preprocessor.
176 // FIXME: There is a very unfortunate problem here, some troubled
177 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
178 // really support that we would have to parse and then translate
180 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wp_COMMA
,
181 options::OPT_Xpreprocessor
);
184 void Clang::ConstructJob(Compilation
&C
, const JobAction
&JA
,
186 const InputInfo
&Output
,
187 const InputInfoList
&Inputs
,
189 const char *LinkingOutput
) const {
190 const Driver
&D
= getToolChain().getHost().getDriver();
191 ArgStringList CmdArgs
;
193 assert(Inputs
.size() == 1 && "Unable to handle multiple inputs.");
195 CmdArgs
.push_back("-triple");
196 const char *TripleStr
=
197 Args
.MakeArgString(getToolChain().getTripleString().c_str());
198 CmdArgs
.push_back(TripleStr
);
200 if (isa
<AnalyzeJobAction
>(JA
)) {
201 assert(JA
.getType() == types::TY_Plist
&& "Invalid output type.");
202 CmdArgs
.push_back("-analyze");
203 } else if (isa
<PreprocessJobAction
>(JA
)) {
204 if (Output
.getType() == types::TY_Dependencies
)
205 CmdArgs
.push_back("-Eonly");
207 CmdArgs
.push_back("-E");
208 } else if (isa
<PrecompileJobAction
>(JA
)) {
210 CmdArgs
.push_back("-emit-pch");
212 CmdArgs
.push_back("-emit-pth");
214 assert(isa
<CompileJobAction
>(JA
) && "Invalid action for clang tool.");
216 if (JA
.getType() == types::TY_Nothing
) {
217 CmdArgs
.push_back("-fsyntax-only");
218 } else if (JA
.getType() == types::TY_LLVMAsm
) {
219 CmdArgs
.push_back("-emit-llvm");
220 } else if (JA
.getType() == types::TY_LLVMBC
) {
221 CmdArgs
.push_back("-emit-llvm-bc");
222 } else if (JA
.getType() == types::TY_PP_Asm
) {
223 CmdArgs
.push_back("-S");
227 // The make clang go fast button.
228 CmdArgs
.push_back("-disable-free");
230 // Set the main file name, so that debug info works even with
232 CmdArgs
.push_back("-main-file-name");
233 CmdArgs
.push_back(darwin::CC1::getBaseInputName(Args
, Inputs
));
235 // Some flags which affect the language (via preprocessor
236 // defines). See darwin::CC1::AddCPPArgs.
237 if (Args
.hasArg(options::OPT_static
))
238 CmdArgs
.push_back("-static-define");
240 if (isa
<AnalyzeJobAction
>(JA
)) {
241 // Add default argument set.
242 if (!Args
.hasArg(options::OPT__analyzer_no_default_checks
)) {
243 CmdArgs
.push_back("-warn-dead-stores");
244 CmdArgs
.push_back("-checker-cfref");
245 CmdArgs
.push_back("-analyzer-eagerly-assume");
246 CmdArgs
.push_back("-warn-objc-methodsigs");
247 // Do not enable the missing -dealloc check.
248 // '-warn-objc-missing-dealloc',
249 CmdArgs
.push_back("-warn-objc-unused-ivars");
252 // Set the output format. The default is plist, for (lame) historical
254 CmdArgs
.push_back("-analyzer-output");
255 if (Arg
*A
= Args
.getLastArg(options::OPT__analyzer_output
))
256 CmdArgs
.push_back(A
->getValue(Args
));
258 CmdArgs
.push_back("plist");
260 // Add -Xanalyzer arguments when running as analyzer.
261 Args
.AddAllArgValues(CmdArgs
, options::OPT_Xanalyzer
);
264 // Perform argument translation for LLVM backend. This
265 // takes some care in reconciling with llvm-gcc. The
266 // issue is that llvm-gcc translates these options based on
267 // the values in cc1, whereas we are processing based on
268 // the driver arguments.
270 // FIXME: This is currently broken for -f flags when -fno
271 // variants are present.
273 // This comes from the default translation the driver + cc1
274 // would do to enable flag_pic.
276 // FIXME: Centralize this code.
277 bool PICEnabled
= (Args
.hasArg(options::OPT_fPIC
) ||
278 Args
.hasArg(options::OPT_fpic
) ||
279 Args
.hasArg(options::OPT_fPIE
) ||
280 Args
.hasArg(options::OPT_fpie
));
281 bool PICDisabled
= (Args
.hasArg(options::OPT_mkernel
) ||
282 Args
.hasArg(options::OPT_static
));
283 const char *Model
= getToolChain().GetForcedPicModel();
285 if (Args
.hasArg(options::OPT_mdynamic_no_pic
))
286 Model
= "dynamic-no-pic";
287 else if (PICDisabled
)
292 Model
= getToolChain().GetDefaultRelocationModel();
294 CmdArgs
.push_back("--relocation-model");
295 CmdArgs
.push_back(Model
);
297 // Infer the __PIC__ value.
299 // FIXME: This isn't quite right on Darwin, which always sets
301 if (strcmp(Model
, "pic") == 0 || strcmp(Model
, "dynamic-no-pic") == 0) {
302 if (Args
.hasArg(options::OPT_fPIC
))
303 CmdArgs
.push_back("-pic-level=2");
305 CmdArgs
.push_back("-pic-level=1");
308 if (Args
.hasArg(options::OPT_ftime_report
))
309 CmdArgs
.push_back("--time-passes");
310 // FIXME: Set --enable-unsafe-fp-math.
311 if (!Args
.hasArg(options::OPT_fomit_frame_pointer
))
312 CmdArgs
.push_back("--disable-fp-elim");
313 if (!Args
.hasFlag(options::OPT_fzero_initialized_in_bss
,
314 options::OPT_fno_zero_initialized_in_bss
,
316 CmdArgs
.push_back("--nozero-initialized-in-bss");
317 if (Args
.hasArg(options::OPT_dA
) || Args
.hasArg(options::OPT_fverbose_asm
))
318 CmdArgs
.push_back("--asm-verbose");
319 if (Args
.hasArg(options::OPT_fdebug_pass_structure
))
320 CmdArgs
.push_back("--debug-pass=Structure");
321 if (Args
.hasArg(options::OPT_fdebug_pass_arguments
))
322 CmdArgs
.push_back("--debug-pass=Arguments");
323 // FIXME: set --inline-threshhold=50 if (optimize_size || optimize
325 if (Args
.hasFlag(options::OPT_funwind_tables
,
326 options::OPT_fno_unwind_tables
,
327 (getToolChain().IsUnwindTablesDefault() &&
328 !Args
.hasArg(options::OPT_mkernel
))))
329 CmdArgs
.push_back("--unwind-tables=1");
331 CmdArgs
.push_back("--unwind-tables=0");
332 if (!Args
.hasFlag(options::OPT_mred_zone
,
333 options::OPT_mno_red_zone
,
335 Args
.hasArg(options::OPT_mkernel
) ||
336 Args
.hasArg(options::OPT_fapple_kext
))
337 CmdArgs
.push_back("--disable-red-zone");
338 if (Args
.hasFlag(options::OPT_msoft_float
,
339 options::OPT_mno_soft_float
,
341 CmdArgs
.push_back("--no-implicit-float");
343 // FIXME: Handle -mtune=.
344 (void) Args
.hasArg(options::OPT_mtune_EQ
);
346 if (const Arg
*A
= Args
.getLastArg(options::OPT_march_EQ
)) {
347 // FIXME: We may need some translation here from the options gcc takes to
348 // names the LLVM backend understand?
349 CmdArgs
.push_back("-mcpu");
350 CmdArgs
.push_back(A
->getValue(Args
));
352 // Select default CPU.
354 // FIXME: Need target hooks.
355 if (memcmp(getToolChain().getOS().c_str(), "darwin", 6) == 0) {
356 if (getToolChain().getArchName() == "x86_64")
357 CmdArgs
.push_back("--mcpu=core2");
358 else if (getToolChain().getArchName() == "i386")
359 CmdArgs
.push_back("--mcpu=yonah");
361 if (getToolChain().getArchName() == "x86_64")
362 CmdArgs
.push_back("--mcpu=x86-64");
363 else if (getToolChain().getArchName() == "i386")
364 CmdArgs
.push_back("--mcpu=pentium4");
368 // FIXME: Use iterator.
369 for (ArgList::const_iterator
370 it
= Args
.begin(), ie
= Args
.end(); it
!= ie
; ++it
) {
372 if (A
->getOption().matches(options::OPT_m_x86_Features_Group
)) {
373 const char *Name
= A
->getOption().getName();
376 assert(Name
[0] == '-' && Name
[1] == 'm' && "Invalid feature name.");
379 bool IsNegative
= memcmp(Name
, "no-", 3) == 0;
384 CmdArgs
.push_back("-target-feature");
385 CmdArgs
.push_back(MakeFormattedString(Args
,
387 IsNegative
? '-' : '+',
392 if (Args
.hasFlag(options::OPT_fmath_errno
,
393 options::OPT_fno_math_errno
,
394 getToolChain().IsMathErrnoDefault()))
395 CmdArgs
.push_back("--fmath-errno=1");
397 CmdArgs
.push_back("--fmath-errno=0");
399 if (Arg
*A
= Args
.getLastArg(options::OPT_flimited_precision_EQ
)) {
400 CmdArgs
.push_back("--limit-float-precision");
401 CmdArgs
.push_back(A
->getValue(Args
));
404 // FIXME: Add --stack-protector-buffer-size=<xxx> on
408 if ((Unsupported
= Args
.getLastArg(options::OPT_MG
)) ||
409 (Unsupported
= Args
.getLastArg(options::OPT_MQ
)) ||
410 (Unsupported
= Args
.getLastArg(options::OPT_iframework
)))
411 D
.Diag(clang::diag::err_drv_clang_unsupported
)
412 << Unsupported
->getOption().getName();
414 Args
.AddAllArgs(CmdArgs
, options::OPT_v
);
415 Args
.AddLastArg(CmdArgs
, options::OPT_P
);
416 Args
.AddLastArg(CmdArgs
, options::OPT_mmacosx_version_min_EQ
);
417 Args
.AddLastArg(CmdArgs
, options::OPT_miphoneos_version_min_EQ
);
418 Args
.AddLastArg(CmdArgs
, options::OPT_print_ivar_layout
);
420 // Special case debug options to only pass -g to clang. This is
422 if (Args
.hasArg(options::OPT_g_Group
))
423 CmdArgs
.push_back("-g");
425 Args
.AddLastArg(CmdArgs
, options::OPT_nostdinc
);
427 Args
.AddLastArg(CmdArgs
, options::OPT_isysroot
);
429 // Add preprocessing options like -I, -D, etc. if we are using the
432 // FIXME: Support -fpreprocessed
433 types::ID InputType
= Inputs
[0].getType();
434 if (types::getPreprocessedType(InputType
) != types::TY_INVALID
)
435 AddPreprocessingOptions(D
, Args
, CmdArgs
, Output
, Inputs
);
437 // Manually translate -O to -O1 and -O4 to -O3; let clang reject
439 if (Arg
*A
= Args
.getLastArg(options::OPT_O_Group
)) {
440 if (A
->getOption().getId() == options::OPT_O4
)
441 CmdArgs
.push_back("-O3");
442 else if (A
->getValue(Args
)[0] == '\0')
443 CmdArgs
.push_back("-O1");
445 A
->render(Args
, CmdArgs
);
448 Args
.AddAllArgs(CmdArgs
, options::OPT_W_Group
, options::OPT_pedantic_Group
);
449 Args
.AddLastArg(CmdArgs
, options::OPT_w
);
451 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
452 // (-ansi is equivalent to -std=c89).
454 // If a std is supplied, only add -trigraphs if it follows the
456 if (Arg
*Std
= Args
.getLastArg(options::OPT_std_EQ
, options::OPT_ansi
)) {
457 if (Std
->getOption().matches(options::OPT_ansi
))
458 CmdArgs
.push_back("-std=c89");
460 Std
->render(Args
, CmdArgs
);
462 if (Arg
*A
= Args
.getLastArg(options::OPT_trigraphs
))
463 if (A
->getIndex() > Std
->getIndex())
464 A
->render(Args
, CmdArgs
);
466 // Honor -std-default.
467 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_std_default_EQ
,
468 "-std=", /*Joined=*/true);
469 Args
.AddLastArg(CmdArgs
, options::OPT_trigraphs
);
472 if (Arg
*A
= Args
.getLastArg(options::OPT_ftemplate_depth_
)) {
473 CmdArgs
.push_back("-ftemplate-depth");
474 CmdArgs
.push_back(A
->getValue(Args
));
477 if (Args
.hasArg(options::OPT__relocatable_pch
, true))
478 CmdArgs
.push_back("--relocatable-pch");
480 // Forward -f options which we can pass directly.
481 Args
.AddLastArg(CmdArgs
, options::OPT_femit_all_decls
);
482 Args
.AddLastArg(CmdArgs
, options::OPT_fexceptions
);
483 Args
.AddLastArg(CmdArgs
, options::OPT_ffreestanding
);
484 Args
.AddLastArg(CmdArgs
, options::OPT_fheinous_gnu_extensions
);
485 Args
.AddLastArg(CmdArgs
, options::OPT_fgnu_runtime
);
486 Args
.AddLastArg(CmdArgs
, options::OPT_flax_vector_conversions
);
487 Args
.AddLastArg(CmdArgs
, options::OPT_fmessage_length_EQ
);
488 Args
.AddLastArg(CmdArgs
, options::OPT_fms_extensions
);
489 Args
.AddLastArg(CmdArgs
, options::OPT_fnext_runtime
);
490 Args
.AddLastArg(CmdArgs
, options::OPT_fno_caret_diagnostics
);
491 Args
.AddLastArg(CmdArgs
, options::OPT_fno_show_column
);
492 Args
.AddLastArg(CmdArgs
, options::OPT_fobjc_gc_only
);
493 Args
.AddLastArg(CmdArgs
, options::OPT_fobjc_gc
);
494 Args
.AddLastArg(CmdArgs
, options::OPT_fobjc_sender_dependent_dispatch
);
495 // FIXME: Should we remove this?
496 Args
.AddLastArg(CmdArgs
, options::OPT_fobjc_nonfragile_abi
);
497 Args
.AddLastArg(CmdArgs
, options::OPT_fobjc_tight_layout
);
498 Args
.AddLastArg(CmdArgs
, options::OPT_fdiagnostics_print_source_range_info
);
499 Args
.AddLastArg(CmdArgs
, options::OPT_ftime_report
);
500 Args
.AddLastArg(CmdArgs
, options::OPT_ftrapv
);
501 Args
.AddLastArg(CmdArgs
, options::OPT_fvisibility_EQ
);
502 Args
.AddLastArg(CmdArgs
, options::OPT_fwritable_strings
);
504 // Forward stack protector flags.
505 if (Arg
*A
= Args
.getLastArg(options::OPT_fno_stack_protector
,
506 options::OPT_fstack_protector_all
,
507 options::OPT_fstack_protector
)) {
508 if (A
->getOption().matches(options::OPT_fno_stack_protector
))
509 CmdArgs
.push_back("--stack-protector=0");
510 else if (A
->getOption().matches(options::OPT_fstack_protector
))
511 CmdArgs
.push_back("--stack-protector=1");
513 CmdArgs
.push_back("--stack-protector=2");
516 // Forward -f options with positive and negative forms; we translate
519 // -fbuiltin is default, only pass non-default.
520 if (!Args
.hasFlag(options::OPT_fbuiltin
, options::OPT_fno_builtin
))
521 CmdArgs
.push_back("-fbuiltin=0");
523 // -fblocks default varies depending on platform and language; only
524 // pass if specified.
525 if (Arg
*A
= Args
.getLastArg(options::OPT_fblocks
, options::OPT_fno_blocks
)) {
526 if (A
->getOption().matches(options::OPT_fblocks
))
527 CmdArgs
.push_back("-fblocks");
529 CmdArgs
.push_back("-fblocks=0");
532 // -fsigned-char/-funsigned-char default varies depending on platform; only
533 // pass if specified.
534 if (Arg
*A
= Args
.getLastArg(options::OPT_fsigned_char
,
535 options::OPT_funsigned_char
)) {
536 if (A
->getOption().matches(options::OPT_fsigned_char
))
537 CmdArgs
.push_back("-fsigned-char");
539 CmdArgs
.push_back("-fsigned-char=0");
542 // -fno-pascal-strings is default, only pass non-default. If the
543 // -tool chain happened to translate to -mpascal-strings, we want to
544 // -back translate here.
546 // FIXME: This is gross; that translation should be pulled from the
548 if (Args
.hasFlag(options::OPT_fpascal_strings
,
549 options::OPT_fno_pascal_strings
,
551 Args
.hasFlag(options::OPT_mpascal_strings
,
552 options::OPT_mno_pascal_strings
,
554 CmdArgs
.push_back("-fpascal-strings");
556 // -fcommon is default, only pass non-default.
557 if (!Args
.hasFlag(options::OPT_fcommon
, options::OPT_fno_common
))
558 CmdArgs
.push_back("-fno-common");
560 // -fsigned-bitfields is default, and clang doesn't yet support
561 // --funsigned-bitfields.
562 if (!Args
.hasFlag(options::OPT_fsigned_bitfields
,
563 options::OPT_funsigned_bitfields
))
564 D
.Diag(clang::diag::warn_drv_clang_unsupported
)
565 << Args
.getLastArg(options::OPT_funsigned_bitfields
)->getAsString(Args
);
567 // -fdiagnostics-fixit-info is default, only pass non-default.
568 if (!Args
.hasFlag(options::OPT_fdiagnostics_fixit_info
,
569 options::OPT_fno_diagnostics_fixit_info
))
570 CmdArgs
.push_back("-fno-diagnostics-fixit-info");
572 // Enable -fdiagnostics-show-option by default.
573 if (Args
.hasFlag(options::OPT_fdiagnostics_show_option
,
574 options::OPT_fno_diagnostics_show_option
))
575 CmdArgs
.push_back("-fdiagnostics-show-option");
576 if (!Args
.hasFlag(options::OPT_fcolor_diagnostics
,
577 options::OPT_fno_color_diagnostics
))
578 CmdArgs
.push_back("-fno-color-diagnostics");
579 if (!Args
.hasFlag(options::OPT_fshow_source_location
,
580 options::OPT_fno_show_source_location
))
581 CmdArgs
.push_back("-fno-show-source-location");
583 // -fdollars-in-identifiers default varies depending on platform and
584 // language; only pass if specified.
585 if (Arg
*A
= Args
.getLastArg(options::OPT_fdollars_in_identifiers
,
586 options::OPT_fno_dollars_in_identifiers
)) {
587 if (A
->getOption().matches(options::OPT_fdollars_in_identifiers
))
588 CmdArgs
.push_back("-fdollars-in-identifiers=1");
590 CmdArgs
.push_back("-fdollars-in-identifiers=0");
593 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
594 // practical purposes.
595 if (Arg
*A
= Args
.getLastArg(options::OPT_funit_at_a_time
,
596 options::OPT_fno_unit_at_a_time
)) {
597 if (A
->getOption().matches(options::OPT_fno_unit_at_a_time
))
598 D
.Diag(clang::diag::err_drv_clang_unsupported
) << A
->getAsString(Args
);
601 if (Arg
*A
= Args
.getLastArg(options::OPT_traditional
,
602 options::OPT_traditional_cpp
))
603 D
.Diag(clang::diag::err_drv_clang_unsupported
) << A
->getAsString(Args
);
605 Args
.AddLastArg(CmdArgs
, options::OPT_dM
);
606 Args
.AddLastArg(CmdArgs
, options::OPT_dD
);
608 Args
.AddAllArgValues(CmdArgs
, options::OPT_Xclang
);
609 Args
.AddAllArgValues(CmdArgs
, options::OPT_mllvm
);
611 if (Output
.getType() == types::TY_Dependencies
) {
612 // Handled with other dependency code.
613 } else if (Output
.isPipe()) {
614 CmdArgs
.push_back("-o");
615 CmdArgs
.push_back("-");
616 } else if (Output
.isFilename()) {
617 CmdArgs
.push_back("-o");
618 CmdArgs
.push_back(Output
.getFilename());
620 assert(Output
.isNothing() && "Invalid output.");
623 for (InputInfoList::const_iterator
624 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
625 const InputInfo
&II
= *it
;
626 CmdArgs
.push_back("-x");
627 CmdArgs
.push_back(types::getTypeName(II
.getType()));
629 CmdArgs
.push_back("-");
630 else if (II
.isFilename())
631 CmdArgs
.push_back(II
.getFilename());
633 II
.getInputArg().renderAsInput(Args
, CmdArgs
);
637 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "clang-cc").c_str());
638 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
640 // Explicitly warn that these options are unsupported, even though
641 // we are allowing compilation to continue.
642 // FIXME: Use iterator.
643 for (ArgList::const_iterator
644 it
= Args
.begin(), ie
= Args
.end(); it
!= ie
; ++it
) {
646 if (A
->getOption().matches(options::OPT_pg
)) {
648 D
.Diag(clang::diag::warn_drv_clang_unsupported
)
649 << A
->getAsString(Args
);
653 // Claim some arguments which clang supports automatically.
655 // -fpch-preprocess is used with gcc to add a special marker in the
656 // -output to include the PCH file. Clang's PTH solution is
657 // -completely transparent, so we do not need to deal with it at
659 Args
.ClaimAllArgs(options::OPT_fpch_preprocess
);
661 // Claim some arguments which clang doesn't support, but we don't
662 // care to warn the user about.
664 // FIXME: Use iterator.
665 for (ArgList::const_iterator
666 it
= Args
.begin(), ie
= Args
.end(); it
!= ie
; ++it
) {
668 if (A
->getOption().matches(options::OPT_clang_ignored_f_Group
) ||
669 A
->getOption().matches(options::OPT_clang_ignored_m_Group
))
674 void gcc::Common::ConstructJob(Compilation
&C
, const JobAction
&JA
,
676 const InputInfo
&Output
,
677 const InputInfoList
&Inputs
,
679 const char *LinkingOutput
) const {
680 const Driver
&D
= getToolChain().getHost().getDriver();
681 ArgStringList CmdArgs
;
683 for (ArgList::const_iterator
684 it
= Args
.begin(), ie
= Args
.end(); it
!= ie
; ++it
) {
686 if (A
->getOption().hasForwardToGCC()) {
687 // It is unfortunate that we have to claim here, as this means
688 // we will basically never report anything interesting for
689 // platforms using a generic gcc, even if we are just using gcc
690 // to get to the assembler.
692 A
->render(Args
, CmdArgs
);
696 RenderExtraToolArgs(CmdArgs
);
698 // If using a driver driver, force the arch.
699 const std::string
&Arch
= getToolChain().getArchName();
700 if (getToolChain().getHost().useDriverDriver()) {
701 CmdArgs
.push_back("-arch");
703 // FIXME: Remove these special cases.
704 if (Arch
== "powerpc")
705 CmdArgs
.push_back("ppc");
706 else if (Arch
== "powerpc64")
707 CmdArgs
.push_back("ppc64");
709 CmdArgs
.push_back(Args
.MakeArgString(Arch
.c_str()));
712 // Try to force gcc to match the tool chain we want, if we recognize
715 // FIXME: The triple class should directly provide the information we want
717 if (Arch
== "i386" || Arch
== "powerpc")
718 CmdArgs
.push_back("-m32");
719 else if (Arch
== "x86_64" || Arch
== "powerpc64")
720 CmdArgs
.push_back("-m64");
722 if (Output
.isPipe()) {
723 CmdArgs
.push_back("-o");
724 CmdArgs
.push_back("-");
725 } else if (Output
.isFilename()) {
726 CmdArgs
.push_back("-o");
727 CmdArgs
.push_back(Output
.getFilename());
729 assert(Output
.isNothing() && "Unexpected output");
730 CmdArgs
.push_back("-fsyntax-only");
734 // Only pass -x if gcc will understand it; otherwise hope gcc
735 // understands the suffix correctly. The main use case this would go
736 // wrong in is for linker inputs if they happened to have an odd
737 // suffix; really the only way to get this to happen is a command
738 // like '-x foobar a.c' which will treat a.c like a linker input.
740 // FIXME: For the linker case specifically, can we safely convert
741 // inputs into '-Wl,' options?
742 for (InputInfoList::const_iterator
743 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
744 const InputInfo
&II
= *it
;
746 // Don't try to pass LLVM inputs to a generic gcc.
747 if (II
.getType() == types::TY_LLVMBC
)
748 D
.Diag(clang::diag::err_drv_no_linker_llvm_support
)
749 << getToolChain().getTripleString().c_str();
751 if (types::canTypeBeUserSpecified(II
.getType())) {
752 CmdArgs
.push_back("-x");
753 CmdArgs
.push_back(types::getTypeName(II
.getType()));
757 CmdArgs
.push_back("-");
758 else if (II
.isFilename())
759 CmdArgs
.push_back(II
.getFilename());
761 // Don't render as input, we need gcc to do the translations.
762 II
.getInputArg().render(Args
, CmdArgs
);
765 const char *GCCName
=
766 getToolChain().getHost().getDriver().CCCGenericGCCName
.c_str();
768 Args
.MakeArgString(getToolChain().GetProgramPath(C
, GCCName
).c_str());
769 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
772 void gcc::Preprocess::RenderExtraToolArgs(ArgStringList
&CmdArgs
) const {
773 CmdArgs
.push_back("-E");
776 void gcc::Precompile::RenderExtraToolArgs(ArgStringList
&CmdArgs
) const {
777 // The type is good enough.
780 void gcc::Compile::RenderExtraToolArgs(ArgStringList
&CmdArgs
) const {
781 CmdArgs
.push_back("-S");
784 void gcc::Assemble::RenderExtraToolArgs(ArgStringList
&CmdArgs
) const {
785 CmdArgs
.push_back("-c");
788 void gcc::Link::RenderExtraToolArgs(ArgStringList
&CmdArgs
) const {
789 // The types are (hopefully) good enough.
792 const char *darwin::CC1::getCC1Name(types::ID Type
) const {
795 assert(0 && "Unexpected type for Darwin CC1 tool.");
797 case types::TY_C
: case types::TY_CHeader
:
798 case types::TY_PP_C
: case types::TY_PP_CHeader
:
800 case types::TY_ObjC
: case types::TY_ObjCHeader
:
801 case types::TY_PP_ObjC
: case types::TY_PP_ObjCHeader
:
803 case types::TY_CXX
: case types::TY_CXXHeader
:
804 case types::TY_PP_CXX
: case types::TY_PP_CXXHeader
:
806 case types::TY_ObjCXX
: case types::TY_ObjCXXHeader
:
807 case types::TY_PP_ObjCXX
: case types::TY_PP_ObjCXXHeader
:
812 const char *darwin::CC1::getBaseInputName(const ArgList
&Args
,
813 const InputInfoList
&Inputs
) {
814 llvm::sys::Path
P(Inputs
[0].getBaseInput());
815 return Args
.MakeArgString(P
.getLast().c_str());
818 const char *darwin::CC1::getBaseInputStem(const ArgList
&Args
,
819 const InputInfoList
&Inputs
) {
820 const char *Str
= getBaseInputName(Args
, Inputs
);
822 if (const char *End
= strchr(Str
, '.'))
823 return Args
.MakeArgString(std::string(Str
, End
).c_str());
829 darwin::CC1::getDependencyFileName(const ArgList
&Args
,
830 const InputInfoList
&Inputs
) {
831 // FIXME: Think about this more.
834 if (Arg
*OutputOpt
= Args
.getLastArg(options::OPT_o
)) {
835 std::string
Str(OutputOpt
->getValue(Args
));
837 Res
= Str
.substr(0, Str
.rfind('.'));
839 Res
= darwin::CC1::getBaseInputStem(Args
, Inputs
);
841 return Args
.MakeArgString((Res
+ ".d").c_str());
844 void darwin::CC1::AddCC1Args(const ArgList
&Args
,
845 ArgStringList
&CmdArgs
) const {
846 // Derived from cc1 spec.
848 // FIXME: -fapple-kext seems to disable this too. Investigate.
849 if (!Args
.hasArg(options::OPT_mkernel
) && !Args
.hasArg(options::OPT_static
) &&
850 !Args
.hasArg(options::OPT_mdynamic_no_pic
))
851 CmdArgs
.push_back("-fPIC");
853 // gcc has some code here to deal with when no -mmacosx-version-min
854 // and no -miphoneos-version-min is present, but this never happens
855 // due to tool chain specific argument translation.
857 // FIXME: Remove mthumb
858 // FIXME: Remove mno-thumb
859 // FIXME: Remove faltivec
860 // FIXME: Remove mno-fused-madd
861 // FIXME: Remove mlong-branch
862 // FIXME: Remove mlongcall
863 // FIXME: Remove mcpu=G4
864 // FIXME: Remove mcpu=G5
866 if (Args
.hasArg(options::OPT_g_Flag
) &&
867 !Args
.hasArg(options::OPT_fno_eliminate_unused_debug_symbols
))
868 CmdArgs
.push_back("-feliminate-unused-debug-symbols");
871 void darwin::CC1::AddCC1OptionsArgs(const ArgList
&Args
, ArgStringList
&CmdArgs
,
872 const InputInfoList
&Inputs
,
873 const ArgStringList
&OutputArgs
) const {
874 const Driver
&D
= getToolChain().getHost().getDriver();
876 // Derived from cc1_options spec.
877 if (Args
.hasArg(options::OPT_fast
) ||
878 Args
.hasArg(options::OPT_fastf
) ||
879 Args
.hasArg(options::OPT_fastcp
))
880 CmdArgs
.push_back("-O3");
882 if (Arg
*A
= Args
.getLastArg(options::OPT_pg
))
883 if (Args
.hasArg(options::OPT_fomit_frame_pointer
))
884 D
.Diag(clang::diag::err_drv_argument_not_allowed_with
)
885 << A
->getAsString(Args
) << "-fomit-frame-pointer";
887 AddCC1Args(Args
, CmdArgs
);
889 if (!Args
.hasArg(options::OPT_Q
))
890 CmdArgs
.push_back("-quiet");
892 CmdArgs
.push_back("-dumpbase");
893 CmdArgs
.push_back(darwin::CC1::getBaseInputName(Args
, Inputs
));
895 Args
.AddAllArgs(CmdArgs
, options::OPT_d_Group
);
897 Args
.AddAllArgs(CmdArgs
, options::OPT_m_Group
);
898 Args
.AddAllArgs(CmdArgs
, options::OPT_a_Group
);
900 // FIXME: The goal is to use the user provided -o if that is our
901 // final output, otherwise to drive from the original input
902 // name. Find a clean way to go about this.
903 if ((Args
.hasArg(options::OPT_c
) || Args
.hasArg(options::OPT_S
)) &&
904 Args
.hasArg(options::OPT_o
)) {
905 Arg
*OutputOpt
= Args
.getLastArg(options::OPT_o
);
906 CmdArgs
.push_back("-auxbase-strip");
907 CmdArgs
.push_back(OutputOpt
->getValue(Args
));
909 CmdArgs
.push_back("-auxbase");
910 CmdArgs
.push_back(darwin::CC1::getBaseInputStem(Args
, Inputs
));
913 Args
.AddAllArgs(CmdArgs
, options::OPT_g_Group
);
915 Args
.AddAllArgs(CmdArgs
, options::OPT_O
);
916 // FIXME: -Wall is getting some special treatment. Investigate.
917 Args
.AddAllArgs(CmdArgs
, options::OPT_W_Group
, options::OPT_pedantic_Group
);
918 Args
.AddLastArg(CmdArgs
, options::OPT_w
);
919 Args
.AddAllArgs(CmdArgs
, options::OPT_std_EQ
, options::OPT_ansi
,
920 options::OPT_trigraphs
);
921 if (!Args
.getLastArg(options::OPT_std_EQ
, options::OPT_ansi
)) {
922 // Honor -std-default.
923 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_std_default_EQ
,
924 "-std=", /*Joined=*/true);
927 if (Args
.hasArg(options::OPT_v
))
928 CmdArgs
.push_back("-version");
929 if (Args
.hasArg(options::OPT_pg
))
930 CmdArgs
.push_back("-p");
931 Args
.AddLastArg(CmdArgs
, options::OPT_p
);
933 // The driver treats -fsyntax-only specially.
934 Args
.AddAllArgs(CmdArgs
, options::OPT_f_Group
, options::OPT_fsyntax_only
);
936 Args
.AddAllArgs(CmdArgs
, options::OPT_undef
);
937 if (Args
.hasArg(options::OPT_Qn
))
938 CmdArgs
.push_back("-fno-ident");
940 // FIXME: This isn't correct.
941 //Args.AddLastArg(CmdArgs, options::OPT__help)
942 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
944 CmdArgs
.append(OutputArgs
.begin(), OutputArgs
.end());
946 // FIXME: Still don't get what is happening here. Investigate.
947 Args
.AddAllArgs(CmdArgs
, options::OPT__param
);
949 if (Args
.hasArg(options::OPT_fmudflap
) ||
950 Args
.hasArg(options::OPT_fmudflapth
)) {
951 CmdArgs
.push_back("-fno-builtin");
952 CmdArgs
.push_back("-fno-merge-constants");
955 if (Args
.hasArg(options::OPT_coverage
)) {
956 CmdArgs
.push_back("-fprofile-arcs");
957 CmdArgs
.push_back("-ftest-coverage");
960 if (types::isCXX(Inputs
[0].getType()))
961 CmdArgs
.push_back("-D__private_extern__=extern");
964 void darwin::CC1::AddCPPOptionsArgs(const ArgList
&Args
, ArgStringList
&CmdArgs
,
965 const InputInfoList
&Inputs
,
966 const ArgStringList
&OutputArgs
) const {
967 // Derived from cpp_options
968 AddCPPUniqueOptionsArgs(Args
, CmdArgs
, Inputs
);
970 CmdArgs
.append(OutputArgs
.begin(), OutputArgs
.end());
972 AddCC1Args(Args
, CmdArgs
);
974 // NOTE: The code below has some commonality with cpp_options, but
975 // in classic gcc style ends up sending things in different
976 // orders. This may be a good merge candidate once we drop pedantic
979 Args
.AddAllArgs(CmdArgs
, options::OPT_m_Group
);
980 Args
.AddAllArgs(CmdArgs
, options::OPT_std_EQ
, options::OPT_ansi
,
981 options::OPT_trigraphs
);
982 if (!Args
.getLastArg(options::OPT_std_EQ
, options::OPT_ansi
)) {
983 // Honor -std-default.
984 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_std_default_EQ
,
985 "-std=", /*Joined=*/true);
987 Args
.AddAllArgs(CmdArgs
, options::OPT_W_Group
, options::OPT_pedantic_Group
);
988 Args
.AddLastArg(CmdArgs
, options::OPT_w
);
990 // The driver treats -fsyntax-only specially.
991 Args
.AddAllArgs(CmdArgs
, options::OPT_f_Group
, options::OPT_fsyntax_only
);
993 if (Args
.hasArg(options::OPT_g_Group
) && !Args
.hasArg(options::OPT_g0
) &&
994 !Args
.hasArg(options::OPT_fno_working_directory
))
995 CmdArgs
.push_back("-fworking-directory");
997 Args
.AddAllArgs(CmdArgs
, options::OPT_O
);
998 Args
.AddAllArgs(CmdArgs
, options::OPT_undef
);
999 if (Args
.hasArg(options::OPT_save_temps
))
1000 CmdArgs
.push_back("-fpch-preprocess");
1003 void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList
&Args
,
1004 ArgStringList
&CmdArgs
,
1005 const InputInfoList
&Inputs
) const
1007 const Driver
&D
= getToolChain().getHost().getDriver();
1009 // Derived from cpp_unique_options.
1011 if ((A
= Args
.getLastArg(options::OPT_C
)) ||
1012 (A
= Args
.getLastArg(options::OPT_CC
))) {
1013 if (!Args
.hasArg(options::OPT_E
))
1014 D
.Diag(clang::diag::err_drv_argument_only_allowed_with
)
1015 << A
->getAsString(Args
) << "-E";
1017 if (!Args
.hasArg(options::OPT_Q
))
1018 CmdArgs
.push_back("-quiet");
1019 Args
.AddAllArgs(CmdArgs
, options::OPT_nostdinc
);
1020 Args
.AddLastArg(CmdArgs
, options::OPT_v
);
1021 Args
.AddAllArgs(CmdArgs
, options::OPT_I_Group
, options::OPT_F
);
1022 Args
.AddLastArg(CmdArgs
, options::OPT_P
);
1024 // FIXME: Handle %I properly.
1025 if (getToolChain().getArchName() == "x86_64") {
1026 CmdArgs
.push_back("-imultilib");
1027 CmdArgs
.push_back("x86_64");
1030 if (Args
.hasArg(options::OPT_MD
)) {
1031 CmdArgs
.push_back("-MD");
1032 CmdArgs
.push_back(darwin::CC1::getDependencyFileName(Args
, Inputs
));
1035 if (Args
.hasArg(options::OPT_MMD
)) {
1036 CmdArgs
.push_back("-MMD");
1037 CmdArgs
.push_back(darwin::CC1::getDependencyFileName(Args
, Inputs
));
1040 Args
.AddLastArg(CmdArgs
, options::OPT_M
);
1041 Args
.AddLastArg(CmdArgs
, options::OPT_MM
);
1042 Args
.AddAllArgs(CmdArgs
, options::OPT_MF
);
1043 Args
.AddLastArg(CmdArgs
, options::OPT_MG
);
1044 Args
.AddLastArg(CmdArgs
, options::OPT_MP
);
1045 Args
.AddAllArgs(CmdArgs
, options::OPT_MQ
);
1046 Args
.AddAllArgs(CmdArgs
, options::OPT_MT
);
1047 if (!Args
.hasArg(options::OPT_M
) && !Args
.hasArg(options::OPT_MM
) &&
1048 (Args
.hasArg(options::OPT_MD
) || Args
.hasArg(options::OPT_MMD
))) {
1049 if (Arg
*OutputOpt
= Args
.getLastArg(options::OPT_o
)) {
1050 CmdArgs
.push_back("-MQ");
1051 CmdArgs
.push_back(OutputOpt
->getValue(Args
));
1055 Args
.AddLastArg(CmdArgs
, options::OPT_remap
);
1056 if (Args
.hasArg(options::OPT_g3
))
1057 CmdArgs
.push_back("-dD");
1058 Args
.AddLastArg(CmdArgs
, options::OPT_H
);
1060 AddCPPArgs(Args
, CmdArgs
);
1062 Args
.AddAllArgs(CmdArgs
, options::OPT_D
, options::OPT_U
, options::OPT_A
);
1063 Args
.AddAllArgs(CmdArgs
, options::OPT_i_Group
);
1065 for (InputInfoList::const_iterator
1066 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1067 const InputInfo
&II
= *it
;
1070 CmdArgs
.push_back("-");
1072 CmdArgs
.push_back(II
.getFilename());
1075 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wp_COMMA
,
1076 options::OPT_Xpreprocessor
);
1078 if (Args
.hasArg(options::OPT_fmudflap
)) {
1079 CmdArgs
.push_back("-D_MUDFLAP");
1080 CmdArgs
.push_back("-include");
1081 CmdArgs
.push_back("mf-runtime.h");
1084 if (Args
.hasArg(options::OPT_fmudflapth
)) {
1085 CmdArgs
.push_back("-D_MUDFLAP");
1086 CmdArgs
.push_back("-D_MUDFLAPTH");
1087 CmdArgs
.push_back("-include");
1088 CmdArgs
.push_back("mf-runtime.h");
1092 void darwin::CC1::AddCPPArgs(const ArgList
&Args
,
1093 ArgStringList
&CmdArgs
) const {
1094 // Derived from cpp spec.
1096 if (Args
.hasArg(options::OPT_static
)) {
1097 // The gcc spec is broken here, it refers to dynamic but
1098 // that has been translated. Start by being bug compatible.
1100 // if (!Args.hasArg(arglist.parser.dynamicOption))
1101 CmdArgs
.push_back("-D__STATIC__");
1103 CmdArgs
.push_back("-D__DYNAMIC__");
1105 if (Args
.hasArg(options::OPT_pthread
))
1106 CmdArgs
.push_back("-D_REENTRANT");
1109 void darwin::Preprocess::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1110 Job
&Dest
, const InputInfo
&Output
,
1111 const InputInfoList
&Inputs
,
1112 const ArgList
&Args
,
1113 const char *LinkingOutput
) const {
1114 ArgStringList CmdArgs
;
1116 assert(Inputs
.size() == 1 && "Unexpected number of inputs!");
1118 CmdArgs
.push_back("-E");
1120 if (Args
.hasArg(options::OPT_traditional
) ||
1121 Args
.hasArg(options::OPT_traditional_cpp
))
1122 CmdArgs
.push_back("-traditional-cpp");
1124 ArgStringList OutputArgs
;
1125 if (Output
.isFilename()) {
1126 OutputArgs
.push_back("-o");
1127 OutputArgs
.push_back(Output
.getFilename());
1129 assert(Output
.isPipe() && "Unexpected CC1 output.");
1132 if (Args
.hasArg(options::OPT_E
)) {
1133 AddCPPOptionsArgs(Args
, CmdArgs
, Inputs
, OutputArgs
);
1135 AddCPPOptionsArgs(Args
, CmdArgs
, Inputs
, ArgStringList());
1136 CmdArgs
.append(OutputArgs
.begin(), OutputArgs
.end());
1139 Args
.AddAllArgs(CmdArgs
, options::OPT_d_Group
);
1141 const char *CC1Name
= getCC1Name(Inputs
[0].getType());
1143 Args
.MakeArgString(getToolChain().GetProgramPath(C
, CC1Name
).c_str());
1144 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1147 void darwin::Compile::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1148 Job
&Dest
, const InputInfo
&Output
,
1149 const InputInfoList
&Inputs
,
1150 const ArgList
&Args
,
1151 const char *LinkingOutput
) const {
1152 const Driver
&D
= getToolChain().getHost().getDriver();
1153 ArgStringList CmdArgs
;
1155 assert(Inputs
.size() == 1 && "Unexpected number of inputs!");
1157 types::ID InputType
= Inputs
[0].getType();
1159 if ((A
= Args
.getLastArg(options::OPT_traditional
)))
1160 D
.Diag(clang::diag::err_drv_argument_only_allowed_with
)
1161 << A
->getAsString(Args
) << "-E";
1163 if (Output
.getType() == types::TY_LLVMAsm
)
1164 CmdArgs
.push_back("-emit-llvm");
1165 else if (Output
.getType() == types::TY_LLVMBC
)
1166 CmdArgs
.push_back("-emit-llvm-bc");
1168 ArgStringList OutputArgs
;
1169 if (Output
.getType() != types::TY_PCH
) {
1170 OutputArgs
.push_back("-o");
1171 if (Output
.isPipe())
1172 OutputArgs
.push_back("-");
1173 else if (Output
.isNothing())
1174 OutputArgs
.push_back("/dev/null");
1176 OutputArgs
.push_back(Output
.getFilename());
1179 // There is no need for this level of compatibility, but it makes
1181 bool OutputArgsEarly
= (Args
.hasArg(options::OPT_fsyntax_only
) ||
1182 Args
.hasArg(options::OPT_S
));
1184 if (types::getPreprocessedType(InputType
) != types::TY_INVALID
) {
1185 AddCPPUniqueOptionsArgs(Args
, CmdArgs
, Inputs
);
1186 if (OutputArgsEarly
) {
1187 AddCC1OptionsArgs(Args
, CmdArgs
, Inputs
, OutputArgs
);
1189 AddCC1OptionsArgs(Args
, CmdArgs
, Inputs
, ArgStringList());
1190 CmdArgs
.append(OutputArgs
.begin(), OutputArgs
.end());
1193 CmdArgs
.push_back("-fpreprocessed");
1195 // FIXME: There is a spec command to remove
1196 // -fpredictive-compilation args here. Investigate.
1198 for (InputInfoList::const_iterator
1199 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1200 const InputInfo
&II
= *it
;
1203 CmdArgs
.push_back("-");
1205 CmdArgs
.push_back(II
.getFilename());
1208 if (OutputArgsEarly
) {
1209 AddCC1OptionsArgs(Args
, CmdArgs
, Inputs
, OutputArgs
);
1211 AddCC1OptionsArgs(Args
, CmdArgs
, Inputs
, ArgStringList());
1212 CmdArgs
.append(OutputArgs
.begin(), OutputArgs
.end());
1216 if (Output
.getType() == types::TY_PCH
) {
1217 assert(Output
.isFilename() && "Invalid PCH output.");
1219 CmdArgs
.push_back("-o");
1220 // NOTE: gcc uses a temp .s file for this, but there doesn't seem
1221 // to be a good reason.
1222 CmdArgs
.push_back("/dev/null");
1224 CmdArgs
.push_back("--output-pch=");
1225 CmdArgs
.push_back(Output
.getFilename());
1228 const char *CC1Name
= getCC1Name(Inputs
[0].getType());
1230 Args
.MakeArgString(getToolChain().GetProgramPath(C
, CC1Name
).c_str());
1231 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1234 void darwin::Assemble::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1235 Job
&Dest
, const InputInfo
&Output
,
1236 const InputInfoList
&Inputs
,
1237 const ArgList
&Args
,
1238 const char *LinkingOutput
) const {
1239 ArgStringList CmdArgs
;
1241 assert(Inputs
.size() == 1 && "Unexpected number of inputs.");
1242 const InputInfo
&Input
= Inputs
[0];
1244 // Bit of a hack, this is only used for original inputs.
1246 // FIXME: This is broken for preprocessed .s inputs.
1247 if (Input
.isFilename() &&
1248 strcmp(Input
.getFilename(), Input
.getBaseInput()) == 0) {
1249 if (Args
.hasArg(options::OPT_gstabs
))
1250 CmdArgs
.push_back("--gstabs");
1251 else if (Args
.hasArg(options::OPT_g_Group
))
1252 CmdArgs
.push_back("--gdwarf2");
1255 // Derived from asm spec.
1256 CmdArgs
.push_back("-arch");
1257 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().getArchName().c_str()));
1259 CmdArgs
.push_back("-force_cpusubtype_ALL");
1260 if ((Args
.hasArg(options::OPT_mkernel
) ||
1261 Args
.hasArg(options::OPT_static
) ||
1262 Args
.hasArg(options::OPT_fapple_kext
)) &&
1263 !Args
.hasArg(options::OPT_dynamic
))
1264 CmdArgs
.push_back("-static");
1266 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wa_COMMA
,
1267 options::OPT_Xassembler
);
1269 assert(Output
.isFilename() && "Unexpected lipo output.");
1270 CmdArgs
.push_back("-o");
1271 CmdArgs
.push_back(Output
.getFilename());
1273 if (Input
.isPipe()) {
1274 CmdArgs
.push_back("-");
1276 assert(Input
.isFilename() && "Invalid input.");
1277 CmdArgs
.push_back(Input
.getFilename());
1280 // asm_final spec is empty.
1283 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "as").c_str());
1284 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1287 /// Helper routine for seeing if we should use dsymutil; this is a
1288 /// gcc compatible hack, we should remove it and use the input
1289 /// type information.
1290 static bool isSourceSuffix(const char *Str
) {
1291 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm',
1293 switch (strlen(Str
)) {
1297 return (memcmp(Str
, "C", 1) == 0 ||
1298 memcmp(Str
, "c", 1) == 0 ||
1299 memcmp(Str
, "m", 1) == 0);
1301 return (memcmp(Str
, "cc", 2) == 0 ||
1302 memcmp(Str
, "cp", 2) == 0 ||
1303 memcmp(Str
, "mm", 2) == 0);
1305 return (memcmp(Str
, "CPP", 3) == 0 ||
1306 memcmp(Str
, "c++", 3) == 0 ||
1307 memcmp(Str
, "cpp", 3) == 0 ||
1308 memcmp(Str
, "cxx", 3) == 0);
1312 static bool isMacosxVersionLT(unsigned (&A
)[3], unsigned (&B
)[3]) {
1313 for (unsigned i
=0; i
< 3; ++i
) {
1314 if (A
[i
] > B
[i
]) return false;
1315 if (A
[i
] < B
[i
]) return true;
1320 static bool isMacosxVersionLT(unsigned (&A
)[3],
1321 unsigned V0
, unsigned V1
=0, unsigned V2
=0) {
1322 unsigned B
[3] = { V0
, V1
, V2
};
1323 return isMacosxVersionLT(A
, B
);
1326 const toolchains::Darwin_X86
&darwin::Link::getDarwinToolChain() const {
1327 return reinterpret_cast<const toolchains::Darwin_X86
&>(getToolChain());
1330 void darwin::Link::AddDarwinArch(const ArgList
&Args
,
1331 ArgStringList
&CmdArgs
) const {
1332 // Derived from darwin_arch spec.
1333 CmdArgs
.push_back("-arch");
1334 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().getArchName().c_str()));
1337 void darwin::Link::AddDarwinSubArch(const ArgList
&Args
,
1338 ArgStringList
&CmdArgs
) const {
1339 // Derived from darwin_subarch spec, not sure what the distinction
1340 // exists for but at least for this chain it is the same.
1341 AddDarwinArch(Args
, CmdArgs
);
1344 void darwin::Link::AddLinkArgs(const ArgList
&Args
,
1345 ArgStringList
&CmdArgs
) const {
1346 const Driver
&D
= getToolChain().getHost().getDriver();
1348 // Derived from the "link" spec.
1349 Args
.AddAllArgs(CmdArgs
, options::OPT_static
);
1350 if (!Args
.hasArg(options::OPT_static
))
1351 CmdArgs
.push_back("-dynamic");
1352 if (Args
.hasArg(options::OPT_fgnu_runtime
)) {
1353 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
1354 // here. How do we wish to handle such things?
1357 if (!Args
.hasArg(options::OPT_dynamiclib
)) {
1358 if (Args
.hasArg(options::OPT_force__cpusubtype__ALL
)) {
1359 AddDarwinArch(Args
, CmdArgs
);
1360 CmdArgs
.push_back("-force_cpusubtype_ALL");
1362 AddDarwinSubArch(Args
, CmdArgs
);
1364 Args
.AddLastArg(CmdArgs
, options::OPT_bundle
);
1365 Args
.AddAllArgs(CmdArgs
, options::OPT_bundle__loader
);
1366 Args
.AddAllArgs(CmdArgs
, options::OPT_client__name
);
1369 if ((A
= Args
.getLastArg(options::OPT_compatibility__version
)) ||
1370 (A
= Args
.getLastArg(options::OPT_current__version
)) ||
1371 (A
= Args
.getLastArg(options::OPT_install__name
)))
1372 D
.Diag(clang::diag::err_drv_argument_only_allowed_with
)
1373 << A
->getAsString(Args
) << "-dynamiclib";
1375 Args
.AddLastArg(CmdArgs
, options::OPT_force__flat__namespace
);
1376 Args
.AddLastArg(CmdArgs
, options::OPT_keep__private__externs
);
1377 Args
.AddLastArg(CmdArgs
, options::OPT_private__bundle
);
1379 CmdArgs
.push_back("-dylib");
1382 if ((A
= Args
.getLastArg(options::OPT_bundle
)) ||
1383 (A
= Args
.getLastArg(options::OPT_bundle__loader
)) ||
1384 (A
= Args
.getLastArg(options::OPT_client__name
)) ||
1385 (A
= Args
.getLastArg(options::OPT_force__flat__namespace
)) ||
1386 (A
= Args
.getLastArg(options::OPT_keep__private__externs
)) ||
1387 (A
= Args
.getLastArg(options::OPT_private__bundle
)))
1388 D
.Diag(clang::diag::err_drv_argument_not_allowed_with
)
1389 << A
->getAsString(Args
) << "-dynamiclib";
1391 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_compatibility__version
,
1392 "-dylib_compatibility_version");
1393 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_current__version
,
1394 "-dylib_current_version");
1396 if (Args
.hasArg(options::OPT_force__cpusubtype__ALL
)) {
1397 AddDarwinArch(Args
, CmdArgs
);
1398 // NOTE: We don't add -force_cpusubtype_ALL on this path. Ok.
1400 AddDarwinSubArch(Args
, CmdArgs
);
1402 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_install__name
,
1403 "-dylib_install_name");
1406 Args
.AddLastArg(CmdArgs
, options::OPT_all__load
);
1407 Args
.AddAllArgs(CmdArgs
, options::OPT_allowable__client
);
1408 Args
.AddLastArg(CmdArgs
, options::OPT_bind__at__load
);
1409 Args
.AddLastArg(CmdArgs
, options::OPT_dead__strip
);
1410 Args
.AddLastArg(CmdArgs
, options::OPT_no__dead__strip__inits__and__terms
);
1411 Args
.AddAllArgs(CmdArgs
, options::OPT_dylib__file
);
1412 Args
.AddLastArg(CmdArgs
, options::OPT_dynamic
);
1413 Args
.AddAllArgs(CmdArgs
, options::OPT_exported__symbols__list
);
1414 Args
.AddLastArg(CmdArgs
, options::OPT_flat__namespace
);
1415 Args
.AddAllArgs(CmdArgs
, options::OPT_headerpad__max__install__names
);
1416 Args
.AddAllArgs(CmdArgs
, options::OPT_image__base
);
1417 Args
.AddAllArgs(CmdArgs
, options::OPT_init
);
1419 if (!Args
.hasArg(options::OPT_mmacosx_version_min_EQ
)) {
1420 if (!Args
.hasArg(options::OPT_miphoneos_version_min_EQ
)) {
1421 // FIXME: I don't understand what is going on here. This is
1422 // supposed to come from darwin_ld_minversion, but gcc doesn't
1423 // seem to be following that; it must be getting overridden
1425 CmdArgs
.push_back("-macosx_version_min");
1426 CmdArgs
.push_back(getDarwinToolChain().getMacosxVersionStr());
1429 // Adding all arguments doesn't make sense here but this is what
1431 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_mmacosx_version_min_EQ
,
1432 "-macosx_version_min");
1435 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_miphoneos_version_min_EQ
,
1436 "-iphoneos_version_min");
1437 Args
.AddLastArg(CmdArgs
, options::OPT_nomultidefs
);
1438 Args
.AddLastArg(CmdArgs
, options::OPT_multi__module
);
1439 Args
.AddLastArg(CmdArgs
, options::OPT_single__module
);
1440 Args
.AddAllArgs(CmdArgs
, options::OPT_multiply__defined
);
1441 Args
.AddAllArgs(CmdArgs
, options::OPT_multiply__defined__unused
);
1443 if (Args
.hasArg(options::OPT_fpie
))
1444 CmdArgs
.push_back("-pie");
1446 Args
.AddLastArg(CmdArgs
, options::OPT_prebind
);
1447 Args
.AddLastArg(CmdArgs
, options::OPT_noprebind
);
1448 Args
.AddLastArg(CmdArgs
, options::OPT_nofixprebinding
);
1449 Args
.AddLastArg(CmdArgs
, options::OPT_prebind__all__twolevel__modules
);
1450 Args
.AddLastArg(CmdArgs
, options::OPT_read__only__relocs
);
1451 Args
.AddAllArgs(CmdArgs
, options::OPT_sectcreate
);
1452 Args
.AddAllArgs(CmdArgs
, options::OPT_sectorder
);
1453 Args
.AddAllArgs(CmdArgs
, options::OPT_seg1addr
);
1454 Args
.AddAllArgs(CmdArgs
, options::OPT_segprot
);
1455 Args
.AddAllArgs(CmdArgs
, options::OPT_segaddr
);
1456 Args
.AddAllArgs(CmdArgs
, options::OPT_segs__read__only__addr
);
1457 Args
.AddAllArgs(CmdArgs
, options::OPT_segs__read__write__addr
);
1458 Args
.AddAllArgs(CmdArgs
, options::OPT_seg__addr__table
);
1459 Args
.AddAllArgs(CmdArgs
, options::OPT_seg__addr__table__filename
);
1460 Args
.AddAllArgs(CmdArgs
, options::OPT_sub__library
);
1461 Args
.AddAllArgs(CmdArgs
, options::OPT_sub__umbrella
);
1462 Args
.AddAllArgsTranslated(CmdArgs
, options::OPT_isysroot
, "-syslibroot");
1463 Args
.AddLastArg(CmdArgs
, options::OPT_twolevel__namespace
);
1464 Args
.AddLastArg(CmdArgs
, options::OPT_twolevel__namespace__hints
);
1465 Args
.AddAllArgs(CmdArgs
, options::OPT_umbrella
);
1466 Args
.AddAllArgs(CmdArgs
, options::OPT_undefined
);
1467 Args
.AddAllArgs(CmdArgs
, options::OPT_unexported__symbols__list
);
1468 Args
.AddAllArgs(CmdArgs
, options::OPT_weak__reference__mismatches
);
1470 if (!Args
.hasArg(options::OPT_weak__reference__mismatches
)) {
1471 CmdArgs
.push_back("-weak_reference_mismatches");
1472 CmdArgs
.push_back("non-weak");
1475 Args
.AddLastArg(CmdArgs
, options::OPT_X_Flag
);
1476 Args
.AddAllArgs(CmdArgs
, options::OPT_y
);
1477 Args
.AddLastArg(CmdArgs
, options::OPT_w
);
1478 Args
.AddAllArgs(CmdArgs
, options::OPT_pagezero__size
);
1479 Args
.AddAllArgs(CmdArgs
, options::OPT_segs__read__
);
1480 Args
.AddLastArg(CmdArgs
, options::OPT_seglinkedit
);
1481 Args
.AddLastArg(CmdArgs
, options::OPT_noseglinkedit
);
1482 Args
.AddAllArgs(CmdArgs
, options::OPT_sectalign
);
1483 Args
.AddAllArgs(CmdArgs
, options::OPT_sectobjectsymbols
);
1484 Args
.AddAllArgs(CmdArgs
, options::OPT_segcreate
);
1485 Args
.AddLastArg(CmdArgs
, options::OPT_whyload
);
1486 Args
.AddLastArg(CmdArgs
, options::OPT_whatsloaded
);
1487 Args
.AddAllArgs(CmdArgs
, options::OPT_dylinker__install__name
);
1488 Args
.AddLastArg(CmdArgs
, options::OPT_dylinker
);
1489 Args
.AddLastArg(CmdArgs
, options::OPT_Mach
);
1492 void darwin::Link::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1493 Job
&Dest
, const InputInfo
&Output
,
1494 const InputInfoList
&Inputs
,
1495 const ArgList
&Args
,
1496 const char *LinkingOutput
) const {
1497 assert(Output
.getType() == types::TY_Image
&& "Invalid linker output type.");
1498 // The logic here is derived from gcc's behavior; most of which
1499 // comes from specs (starting with link_command). Consult gcc for
1500 // more information.
1502 // FIXME: The spec references -fdump= which seems to have
1505 ArgStringList CmdArgs
;
1507 // I'm not sure why this particular decomposition exists in gcc, but
1508 // we follow suite for ease of comparison.
1509 AddLinkArgs(Args
, CmdArgs
);
1511 // FIXME: gcc has %{x} in here. How could this ever happen? Cruft?
1512 Args
.AddAllArgs(CmdArgs
, options::OPT_d_Flag
);
1513 Args
.AddAllArgs(CmdArgs
, options::OPT_s
);
1514 Args
.AddAllArgs(CmdArgs
, options::OPT_t
);
1515 Args
.AddAllArgs(CmdArgs
, options::OPT_Z_Flag
);
1516 Args
.AddAllArgs(CmdArgs
, options::OPT_u_Group
);
1517 Args
.AddAllArgs(CmdArgs
, options::OPT_A
);
1518 Args
.AddLastArg(CmdArgs
, options::OPT_e
);
1519 Args
.AddAllArgs(CmdArgs
, options::OPT_m_Separate
);
1520 Args
.AddAllArgs(CmdArgs
, options::OPT_r
);
1522 // FIXME: This is just being pedantically bug compatible, gcc
1523 // doesn't *mean* to forward this, it just does (yay for pattern
1524 // matching). It doesn't work, of course.
1525 Args
.AddAllArgs(CmdArgs
, options::OPT_object
);
1527 CmdArgs
.push_back("-o");
1528 CmdArgs
.push_back(Output
.getFilename());
1530 unsigned MacosxVersion
[3];
1531 if (Arg
*A
= Args
.getLastArg(options::OPT_mmacosx_version_min_EQ
)) {
1533 if (!Driver::GetReleaseVersion(A
->getValue(Args
), MacosxVersion
[0],
1534 MacosxVersion
[1], MacosxVersion
[2],
1537 const Driver
&D
= getToolChain().getHost().getDriver();
1538 D
.Diag(clang::diag::err_drv_invalid_version_number
)
1539 << A
->getAsString(Args
);
1542 getDarwinToolChain().getMacosxVersion(MacosxVersion
);
1545 if (!Args
.hasArg(options::OPT_A
) &&
1546 !Args
.hasArg(options::OPT_nostdlib
) &&
1547 !Args
.hasArg(options::OPT_nostartfiles
)) {
1548 // Derived from startfile spec.
1549 if (Args
.hasArg(options::OPT_dynamiclib
)) {
1550 // Derived from darwin_dylib1 spec.
1551 if (isMacosxVersionLT(MacosxVersion
, 10, 5))
1552 CmdArgs
.push_back("-ldylib1.o");
1553 else if (isMacosxVersionLT(MacosxVersion
, 10, 6))
1554 CmdArgs
.push_back("-ldylib1.10.5.o");
1556 if (Args
.hasArg(options::OPT_bundle
)) {
1557 if (!Args
.hasArg(options::OPT_static
)) {
1558 // Derived from darwin_bundle1 spec.
1559 if (isMacosxVersionLT(MacosxVersion
, 10, 6))
1560 CmdArgs
.push_back("-lbundle1.o");
1563 if (Args
.hasArg(options::OPT_pg
)) {
1564 if (Args
.hasArg(options::OPT_static
) ||
1565 Args
.hasArg(options::OPT_object
) ||
1566 Args
.hasArg(options::OPT_preload
)) {
1567 CmdArgs
.push_back("-lgcrt0.o");
1569 CmdArgs
.push_back("-lgcrt1.o");
1571 // darwin_crt2 spec is empty.
1574 if (Args
.hasArg(options::OPT_static
) ||
1575 Args
.hasArg(options::OPT_object
) ||
1576 Args
.hasArg(options::OPT_preload
)) {
1577 CmdArgs
.push_back("-lcrt0.o");
1579 // Derived from darwin_crt1 spec.
1580 if (isMacosxVersionLT(MacosxVersion
, 10, 5))
1581 CmdArgs
.push_back("-lcrt1.o");
1582 else if (isMacosxVersionLT(MacosxVersion
, 10, 6))
1583 CmdArgs
.push_back("-lcrt1.10.5.o");
1585 CmdArgs
.push_back("-lcrt1.10.6.o");
1587 // darwin_crt2 spec is empty.
1593 if (Args
.hasArg(options::OPT_shared_libgcc
) &&
1594 !Args
.hasArg(options::OPT_miphoneos_version_min_EQ
) &&
1595 isMacosxVersionLT(MacosxVersion
, 10, 5)) {
1596 const char *Str
= getToolChain().GetFilePath(C
, "crt3.o").c_str();
1597 CmdArgs
.push_back(Args
.MakeArgString(Str
));
1601 Args
.AddAllArgs(CmdArgs
, options::OPT_L
);
1603 if (Args
.hasArg(options::OPT_fopenmp
))
1604 // This is more complicated in gcc...
1605 CmdArgs
.push_back("-lgomp");
1607 // FIXME: Derive these correctly.
1608 const char *TCDir
= getDarwinToolChain().getToolChainDir().c_str();
1609 if (getToolChain().getArchName() == "x86_64") {
1610 CmdArgs
.push_back(MakeFormattedString(Args
,
1611 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir
)));
1612 // Intentionally duplicated for (temporary) gcc bug compatibility.
1613 CmdArgs
.push_back(MakeFormattedString(Args
,
1614 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir
)));
1616 CmdArgs
.push_back(MakeFormattedString(Args
,
1617 llvm::format("-L/usr/lib/%s", TCDir
)));
1618 CmdArgs
.push_back(MakeFormattedString(Args
,
1619 llvm::format("-L/usr/lib/gcc/%s", TCDir
)));
1620 // Intentionally duplicated for (temporary) gcc bug compatibility.
1621 CmdArgs
.push_back(MakeFormattedString(Args
,
1622 llvm::format("-L/usr/lib/gcc/%s", TCDir
)));
1623 CmdArgs
.push_back(MakeFormattedString(Args
,
1624 llvm::format("-L/usr/lib/gcc/%s/../../../%s", TCDir
, TCDir
)));
1625 CmdArgs
.push_back(MakeFormattedString(Args
,
1626 llvm::format("-L/usr/lib/gcc/%s/../../..", TCDir
)));
1628 for (InputInfoList::const_iterator
1629 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1630 const InputInfo
&II
= *it
;
1631 if (II
.isFilename())
1632 CmdArgs
.push_back(II
.getFilename());
1634 II
.getInputArg().renderAsInput(Args
, CmdArgs
);
1637 if (LinkingOutput
) {
1638 CmdArgs
.push_back("-arch_multiple");
1639 CmdArgs
.push_back("-final_output");
1640 CmdArgs
.push_back(LinkingOutput
);
1643 if (Args
.hasArg(options::OPT_fprofile_arcs
) ||
1644 Args
.hasArg(options::OPT_fprofile_generate
) ||
1645 Args
.hasArg(options::OPT_fcreate_profile
) ||
1646 Args
.hasArg(options::OPT_coverage
))
1647 CmdArgs
.push_back("-lgcov");
1649 if (Args
.hasArg(options::OPT_fnested_functions
))
1650 CmdArgs
.push_back("-allow_stack_execute");
1652 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1653 !Args
.hasArg(options::OPT_nodefaultlibs
)) {
1654 // FIXME: g++ is more complicated here, it tries to put -lstdc++
1655 // before -lm, for example.
1656 if (getToolChain().getHost().getDriver().CCCIsCXX
)
1657 CmdArgs
.push_back("-lstdc++");
1659 // link_ssp spec is empty.
1661 // Derived from libgcc and lib specs but refactored.
1662 if (Args
.hasArg(options::OPT_static
)) {
1663 CmdArgs
.push_back("-lgcc_static");
1665 if (Args
.hasArg(options::OPT_static_libgcc
)) {
1666 CmdArgs
.push_back("-lgcc_eh");
1667 } else if (Args
.hasArg(options::OPT_miphoneos_version_min_EQ
)) {
1668 // Derived from darwin_iphoneos_libgcc spec.
1669 CmdArgs
.push_back("-lgcc_s.10.5");
1670 } else if (Args
.hasArg(options::OPT_shared_libgcc
) ||
1671 Args
.hasArg(options::OPT_fexceptions
) ||
1672 Args
.hasArg(options::OPT_fgnu_runtime
)) {
1673 // FIXME: This is probably broken on 10.3?
1674 if (isMacosxVersionLT(MacosxVersion
, 10, 5))
1675 CmdArgs
.push_back("-lgcc_s.10.4");
1676 else if (isMacosxVersionLT(MacosxVersion
, 10, 6))
1677 CmdArgs
.push_back("-lgcc_s.10.5");
1679 if (isMacosxVersionLT(MacosxVersion
, 10, 3, 9))
1681 else if (isMacosxVersionLT(MacosxVersion
, 10, 5))
1682 CmdArgs
.push_back("-lgcc_s.10.4");
1683 else if (isMacosxVersionLT(MacosxVersion
, 10, 6))
1684 CmdArgs
.push_back("-lgcc_s.10.5");
1687 if (isMacosxVersionLT(MacosxVersion
, 10, 6)) {
1688 CmdArgs
.push_back("-lgcc");
1689 CmdArgs
.push_back("-lSystem");
1691 CmdArgs
.push_back("-lSystem");
1692 CmdArgs
.push_back("-lgcc");
1697 if (!Args
.hasArg(options::OPT_A
) &&
1698 !Args
.hasArg(options::OPT_nostdlib
) &&
1699 !Args
.hasArg(options::OPT_nostartfiles
)) {
1700 // endfile_spec is empty.
1703 Args
.AddAllArgs(CmdArgs
, options::OPT_T_Group
);
1704 Args
.AddAllArgs(CmdArgs
, options::OPT_F
);
1707 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "ld").c_str());
1708 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1710 // Find the first non-empty base input (we want to ignore linker
1712 const char *BaseInput
= "";
1713 for (unsigned i
= 0, e
= Inputs
.size(); i
!= e
; ++i
) {
1714 if (Inputs
[i
].getBaseInput()[0] != '\0') {
1715 BaseInput
= Inputs
[i
].getBaseInput();
1720 // Run dsymutil if we are making an executable in a single step.
1722 // FIXME: Currently we don't want to do this when we are part of a
1723 // universal build step, as this would end up creating stray temp
1725 if (!LinkingOutput
&&
1726 Args
.getLastArg(options::OPT_g_Group
) &&
1727 !Args
.getLastArg(options::OPT_gstabs
) &&
1728 !Args
.getLastArg(options::OPT_g0
)) {
1729 // FIXME: This is gross, but matches gcc. The test only considers
1730 // the suffix (not the -x type), and then only of the first
1731 // source input. Awesome.
1732 const char *Suffix
= strrchr(BaseInput
, '.');
1733 if (Suffix
&& isSourceSuffix(Suffix
+ 1)) {
1735 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "dsymutil").c_str());
1736 ArgStringList CmdArgs
;
1737 CmdArgs
.push_back(Output
.getFilename());
1738 C
.getJobs().addCommand(new Command(JA
, Exec
, CmdArgs
));
1743 void darwin::Lipo::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1744 Job
&Dest
, const InputInfo
&Output
,
1745 const InputInfoList
&Inputs
,
1746 const ArgList
&Args
,
1747 const char *LinkingOutput
) const {
1748 ArgStringList CmdArgs
;
1750 CmdArgs
.push_back("-create");
1751 assert(Output
.isFilename() && "Unexpected lipo output.");
1753 CmdArgs
.push_back("-output");
1754 CmdArgs
.push_back(Output
.getFilename());
1756 for (InputInfoList::const_iterator
1757 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1758 const InputInfo
&II
= *it
;
1759 assert(II
.isFilename() && "Unexpected lipo input.");
1760 CmdArgs
.push_back(II
.getFilename());
1763 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "lipo").c_str());
1764 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1767 void openbsd::Assemble::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1768 Job
&Dest
, const InputInfo
&Output
,
1769 const InputInfoList
&Inputs
,
1770 const ArgList
&Args
,
1771 const char *LinkingOutput
) const
1773 ArgStringList CmdArgs
;
1775 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wa_COMMA
,
1776 options::OPT_Xassembler
);
1778 CmdArgs
.push_back("-o");
1779 if (Output
.isPipe())
1780 CmdArgs
.push_back("-");
1782 CmdArgs
.push_back(Output
.getFilename());
1784 for (InputInfoList::const_iterator
1785 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1786 const InputInfo
&II
= *it
;
1788 CmdArgs
.push_back("-");
1790 CmdArgs
.push_back(II
.getFilename());
1794 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "as").c_str());
1795 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1798 void openbsd::Link::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1799 Job
&Dest
, const InputInfo
&Output
,
1800 const InputInfoList
&Inputs
,
1801 const ArgList
&Args
,
1802 const char *LinkingOutput
) const {
1803 const Driver
&D
= getToolChain().getHost().getDriver();
1804 ArgStringList CmdArgs
;
1806 if (Args
.hasArg(options::OPT_static
)) {
1807 CmdArgs
.push_back("-Bstatic");
1809 CmdArgs
.push_back("--eh-frame-hdr");
1810 if (Args
.hasArg(options::OPT_shared
)) {
1811 CmdArgs
.push_back("-Bshareable");
1813 CmdArgs
.push_back("-dynamic-linker");
1814 CmdArgs
.push_back("/usr/libexec/ld.so");
1818 if (Output
.isPipe()) {
1819 CmdArgs
.push_back("-o");
1820 CmdArgs
.push_back("-");
1821 } else if (Output
.isFilename()) {
1822 CmdArgs
.push_back("-o");
1823 CmdArgs
.push_back(Output
.getFilename());
1825 assert(Output
.isNothing() && "Invalid output.");
1828 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1829 !Args
.hasArg(options::OPT_nostartfiles
)) {
1830 if (!Args
.hasArg(options::OPT_shared
)) {
1831 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crt0.o").c_str()));
1832 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbegin.o").c_str()));
1834 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbeginS.o").c_str()));
1838 Args
.AddAllArgs(CmdArgs
, options::OPT_L
);
1839 Args
.AddAllArgs(CmdArgs
, options::OPT_T_Group
);
1840 Args
.AddAllArgs(CmdArgs
, options::OPT_e
);
1842 for (InputInfoList::const_iterator
1843 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1844 const InputInfo
&II
= *it
;
1846 // Don't try to pass LLVM inputs to a generic gcc.
1847 if (II
.getType() == types::TY_LLVMBC
)
1848 D
.Diag(clang::diag::err_drv_no_linker_llvm_support
)
1849 << getToolChain().getTripleString().c_str();
1852 CmdArgs
.push_back("-");
1853 else if (II
.isFilename())
1854 CmdArgs
.push_back(II
.getFilename());
1856 II
.getInputArg().renderAsInput(Args
, CmdArgs
);
1859 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1860 !Args
.hasArg(options::OPT_nodefaultlibs
)) {
1862 if (Args
.hasArg(options::OPT_pthread
))
1863 CmdArgs
.push_back("-pthread");
1864 CmdArgs
.push_back("-lc");
1867 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1868 !Args
.hasArg(options::OPT_nostartfiles
)) {
1869 if (!Args
.hasArg(options::OPT_shared
))
1870 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtend.o").c_str()));
1872 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtendS.o").c_str()));
1876 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "ld").c_str());
1877 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1880 void freebsd::Assemble::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1881 Job
&Dest
, const InputInfo
&Output
,
1882 const InputInfoList
&Inputs
,
1883 const ArgList
&Args
,
1884 const char *LinkingOutput
) const
1886 ArgStringList CmdArgs
;
1888 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
1889 // instruct as in the base system to assemble 32-bit code.
1890 if (getToolChain().getArchName() == "i386")
1891 CmdArgs
.push_back("--32");
1893 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wa_COMMA
,
1894 options::OPT_Xassembler
);
1896 CmdArgs
.push_back("-o");
1897 if (Output
.isPipe())
1898 CmdArgs
.push_back("-");
1900 CmdArgs
.push_back(Output
.getFilename());
1902 for (InputInfoList::const_iterator
1903 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1904 const InputInfo
&II
= *it
;
1906 CmdArgs
.push_back("-");
1908 CmdArgs
.push_back(II
.getFilename());
1912 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "as").c_str());
1913 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
1916 void freebsd::Link::ConstructJob(Compilation
&C
, const JobAction
&JA
,
1917 Job
&Dest
, const InputInfo
&Output
,
1918 const InputInfoList
&Inputs
,
1919 const ArgList
&Args
,
1920 const char *LinkingOutput
) const {
1921 const Driver
&D
= getToolChain().getHost().getDriver();
1922 ArgStringList CmdArgs
;
1924 if (Args
.hasArg(options::OPT_static
)) {
1925 CmdArgs
.push_back("-Bstatic");
1927 CmdArgs
.push_back("--eh-frame-hdr");
1928 if (Args
.hasArg(options::OPT_shared
)) {
1929 CmdArgs
.push_back("-Bshareable");
1931 CmdArgs
.push_back("-dynamic-linker");
1932 CmdArgs
.push_back("/libexec/ld-elf.so.1");
1936 // When building 32-bit code on FreeBSD/amd64, we have to explicitly
1937 // instruct ld in the base system to link 32-bit code.
1938 if (getToolChain().getArchName() == "i386") {
1939 CmdArgs
.push_back("-m");
1940 CmdArgs
.push_back("elf_i386_fbsd");
1943 if (Output
.isPipe()) {
1944 CmdArgs
.push_back("-o");
1945 CmdArgs
.push_back("-");
1946 } else if (Output
.isFilename()) {
1947 CmdArgs
.push_back("-o");
1948 CmdArgs
.push_back(Output
.getFilename());
1950 assert(Output
.isNothing() && "Invalid output.");
1953 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1954 !Args
.hasArg(options::OPT_nostartfiles
)) {
1955 if (!Args
.hasArg(options::OPT_shared
)) {
1956 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crt1.o").c_str()));
1957 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crti.o").c_str()));
1958 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbegin.o").c_str()));
1960 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crti.o").c_str()));
1961 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbeginS.o").c_str()));
1965 Args
.AddAllArgs(CmdArgs
, options::OPT_L
);
1966 Args
.AddAllArgs(CmdArgs
, options::OPT_T_Group
);
1967 Args
.AddAllArgs(CmdArgs
, options::OPT_e
);
1969 for (InputInfoList::const_iterator
1970 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
1971 const InputInfo
&II
= *it
;
1973 // Don't try to pass LLVM inputs to a generic gcc.
1974 if (II
.getType() == types::TY_LLVMBC
)
1975 D
.Diag(clang::diag::err_drv_no_linker_llvm_support
)
1976 << getToolChain().getTripleString().c_str();
1979 CmdArgs
.push_back("-");
1980 else if (II
.isFilename())
1981 CmdArgs
.push_back(II
.getFilename());
1983 II
.getInputArg().renderAsInput(Args
, CmdArgs
);
1986 if (!Args
.hasArg(options::OPT_nostdlib
) &&
1987 !Args
.hasArg(options::OPT_nodefaultlibs
)) {
1988 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
1989 // the default system libraries. Just mimic this for now.
1990 CmdArgs
.push_back("-lgcc");
1991 if (Args
.hasArg(options::OPT_static
)) {
1992 CmdArgs
.push_back("-lgcc_eh");
1994 CmdArgs
.push_back("--as-needed");
1995 CmdArgs
.push_back("-lgcc_s");
1996 CmdArgs
.push_back("--no-as-needed");
1999 if (Args
.hasArg(options::OPT_pthread
))
2000 CmdArgs
.push_back("-lpthread");
2001 CmdArgs
.push_back("-lc");
2003 CmdArgs
.push_back("-lgcc");
2004 if (Args
.hasArg(options::OPT_static
)) {
2005 CmdArgs
.push_back("-lgcc_eh");
2007 CmdArgs
.push_back("--as-needed");
2008 CmdArgs
.push_back("-lgcc_s");
2009 CmdArgs
.push_back("--no-as-needed");
2013 if (!Args
.hasArg(options::OPT_nostdlib
) &&
2014 !Args
.hasArg(options::OPT_nostartfiles
)) {
2015 if (!Args
.hasArg(options::OPT_shared
))
2016 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtend.o").c_str()));
2018 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtendS.o").c_str()));
2019 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtn.o").c_str()));
2023 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "ld").c_str());
2024 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
2029 // For now, DragonFly Assemble does just about the same as for
2030 // FreeBSD, but this may change soon.
2031 void dragonfly::Assemble::ConstructJob(Compilation
&C
, const JobAction
&JA
,
2032 Job
&Dest
, const InputInfo
&Output
,
2033 const InputInfoList
&Inputs
,
2034 const ArgList
&Args
,
2035 const char *LinkingOutput
) const {
2036 ArgStringList CmdArgs
;
2038 // When building 32-bit code on DragonFly/pc64, we have to explicitly
2039 // instruct as in the base system to assemble 32-bit code.
2040 if (getToolChain().getArchName() == "i386")
2041 CmdArgs
.push_back("--32");
2043 Args
.AddAllArgValues(CmdArgs
, options::OPT_Wa_COMMA
,
2044 options::OPT_Xassembler
);
2046 CmdArgs
.push_back("-o");
2047 if (Output
.isPipe())
2048 CmdArgs
.push_back("-");
2050 CmdArgs
.push_back(Output
.getFilename());
2052 for (InputInfoList::const_iterator
2053 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
2054 const InputInfo
&II
= *it
;
2056 CmdArgs
.push_back("-");
2058 CmdArgs
.push_back(II
.getFilename());
2062 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "as").c_str());
2063 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));
2066 void dragonfly::Link::ConstructJob(Compilation
&C
, const JobAction
&JA
,
2067 Job
&Dest
, const InputInfo
&Output
,
2068 const InputInfoList
&Inputs
,
2069 const ArgList
&Args
,
2070 const char *LinkingOutput
) const {
2071 const Driver
&D
= getToolChain().getHost().getDriver();
2072 ArgStringList CmdArgs
;
2074 if (Args
.hasArg(options::OPT_static
)) {
2075 CmdArgs
.push_back("-Bstatic");
2077 if (Args
.hasArg(options::OPT_shared
))
2078 CmdArgs
.push_back("-Bshareable");
2080 CmdArgs
.push_back("-dynamic-linker");
2081 CmdArgs
.push_back("/usr/libexec/ld-elf.so.2");
2085 // When building 32-bit code on DragonFly/pc64, we have to explicitly
2086 // instruct ld in the base system to link 32-bit code.
2087 if (getToolChain().getArchName() == "i386") {
2088 CmdArgs
.push_back("-m");
2089 CmdArgs
.push_back("elf_i386");
2092 if (Output
.isPipe()) {
2093 CmdArgs
.push_back("-o");
2094 CmdArgs
.push_back("-");
2095 } else if (Output
.isFilename()) {
2096 CmdArgs
.push_back("-o");
2097 CmdArgs
.push_back(Output
.getFilename());
2099 assert(Output
.isNothing() && "Invalid output.");
2102 if (!Args
.hasArg(options::OPT_nostdlib
) &&
2103 !Args
.hasArg(options::OPT_nostartfiles
)) {
2104 if (!Args
.hasArg(options::OPT_shared
)) {
2105 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crt1.o").c_str()));
2106 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crti.o").c_str()));
2107 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbegin.o").c_str()));
2109 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crti.o").c_str()));
2110 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtbeginS.o").c_str()));
2114 Args
.AddAllArgs(CmdArgs
, options::OPT_L
);
2115 Args
.AddAllArgs(CmdArgs
, options::OPT_T_Group
);
2116 Args
.AddAllArgs(CmdArgs
, options::OPT_e
);
2118 for (InputInfoList::const_iterator
2119 it
= Inputs
.begin(), ie
= Inputs
.end(); it
!= ie
; ++it
) {
2120 const InputInfo
&II
= *it
;
2122 // Don't try to pass LLVM inputs to a generic gcc.
2123 if (II
.getType() == types::TY_LLVMBC
)
2124 D
.Diag(clang::diag::err_drv_no_linker_llvm_support
)
2125 << getToolChain().getTripleString().c_str();
2128 CmdArgs
.push_back("-");
2129 else if (II
.isFilename())
2130 CmdArgs
.push_back(II
.getFilename());
2132 II
.getInputArg().renderAsInput(Args
, CmdArgs
);
2135 if (!Args
.hasArg(options::OPT_nostdlib
) &&
2136 !Args
.hasArg(options::OPT_nodefaultlibs
)) {
2137 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
2139 CmdArgs
.push_back("-L/usr/lib/gcc41");
2141 if (!Args
.hasArg(options::OPT_static
)) {
2142 CmdArgs
.push_back("-rpath");
2143 CmdArgs
.push_back("/usr/lib/gcc41");
2145 CmdArgs
.push_back("-rpath-link");
2146 CmdArgs
.push_back("/usr/lib/gcc41");
2148 CmdArgs
.push_back("-rpath");
2149 CmdArgs
.push_back("/usr/lib");
2151 CmdArgs
.push_back("-rpath-link");
2152 CmdArgs
.push_back("/usr/lib");
2155 if (Args
.hasArg(options::OPT_shared
)) {
2156 CmdArgs
.push_back("-lgcc_pic");
2158 CmdArgs
.push_back("-lgcc");
2162 if (Args
.hasArg(options::OPT_pthread
))
2163 CmdArgs
.push_back("-lthread_xu");
2165 if (!Args
.hasArg(options::OPT_nolibc
)) {
2166 CmdArgs
.push_back("-lc");
2169 if (Args
.hasArg(options::OPT_shared
)) {
2170 CmdArgs
.push_back("-lgcc_pic");
2172 CmdArgs
.push_back("-lgcc");
2176 if (!Args
.hasArg(options::OPT_nostdlib
) &&
2177 !Args
.hasArg(options::OPT_nostartfiles
)) {
2178 if (!Args
.hasArg(options::OPT_shared
))
2179 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtend.o").c_str()));
2181 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtendS.o").c_str()));
2182 CmdArgs
.push_back(Args
.MakeArgString(getToolChain().GetFilePath(C
, "crtn.o").c_str()));
2186 Args
.MakeArgString(getToolChain().GetProgramPath(C
, "ld").c_str());
2187 Dest
.addCommand(new Command(JA
, Exec
, CmdArgs
));