?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add include needed for MSVC.
[clang/acc.git] / lib / Driver / Tools.cpp
blob2fe2aa1896bec2d8425560a3691b7ca835825333
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
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"
23
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/Support/Format.h"
26 #include "llvm/Support/raw_ostream.h"
27
28 #include "InputInfo.h"
29 #include "ToolChains.h"
30
31 using namespace clang::driver;
32 using namespace clang::driver::tools;
33
34 static const char *MakeFormattedString(const ArgList &Args,
35 const llvm::format_object_base &Fmt) {
36 std::string Str;
37 llvm::raw_string_ostream(Str) << Fmt;
38 return Args.MakeArgString(Str.c_str());
39 }
40
41 void Clang::AddPreprocessingOptions(const Driver &D,
42 const ArgList &Args,
43 ArgStringList &CmdArgs,
44 const InputInfo &Output,
45 const InputInfoList &Inputs) const {
46 Arg *A;
47
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);
54 }
55
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.
62 const char *DepFile;
63 if (Output.getType() == types::TY_Dependencies) {
64 if (Output.isPipe())
65 DepFile = "-";
66 else
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) {
72 DepFile = "-";
73 } else {
74 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
75 }
76 CmdArgs.push_back("-dependency-file");
77 CmdArgs.push_back(DepFile);
78
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;
83
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);
89 } else {
90 // Otherwise derive from the base input.
91 //
92 // FIXME: This should use the computed output file location.
93 llvm::sys::Path P(Inputs[0].getBaseInput());
94
95 P.eraseSuffix();
96 P.appendSuffix("o");
97 DepTarget = Args.MakeArgString(P.getLast().c_str());
98 }
99
100 CmdArgs.push_back("-MT");
101 CmdArgs.push_back(DepTarget);
102 }
103
104 if (A->getOption().getId() == options::OPT_M ||
105 A->getOption().getId() == options::OPT_MD)
106 CmdArgs.push_back("-sys-header-deps");
107 }
108
109 Args.AddLastArg(CmdArgs, options::OPT_MP);
110 Args.AddAllArgs(CmdArgs, options::OPT_MT);
111
112 // FIXME: Use iterator.
113
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
118 // .gch files.
119 for (ArgList::const_iterator
120 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
121 const Arg *A = *it;
122 if (!A->getOption().matches(options::OPT_clang_i_Group))
123 continue;
124
125 if (A->getOption().matches(options::OPT_include)) {
126 bool FoundPTH = false;
127 bool FoundPCH = false;
128 llvm::sys::Path P(A->getValue(Args));
129 if (D.CCCUsePCH) {
130 P.appendSuffix("pch");
131 if (P.exists())
132 FoundPCH = true;
133 else
134 P.eraseSuffix();
135 }
136
137 if (!FoundPCH) {
138 P.appendSuffix("pth");
139 if (P.exists())
140 FoundPTH = true;
141 else
142 P.eraseSuffix();
143 }
144
145 if (!FoundPCH && !FoundPTH) {
146 P.appendSuffix("gch");
147 if (P.exists()) {
148 FoundPCH = D.CCCUsePCH;
149 FoundPTH = !D.CCCUsePCH;
150 }
151 else
152 P.eraseSuffix();
153 }
154
155 if (FoundPCH || FoundPTH) {
156 A->claim();
157 if (D.CCCUsePCH)
158 CmdArgs.push_back("-include-pch");
159 else
160 CmdArgs.push_back("-include-pth");
161 CmdArgs.push_back(Args.MakeArgString(P.c_str()));
162 continue;
163 }
164 }
165
166 // Not translated, render as usual.
167 A->claim();
168 A->render(Args, CmdArgs);
169 }
170
171 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
172 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
173
174 // Add -Wp, and -Xassembler if using the preprocessor.
175
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
179 // those options. :(
180 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
181 options::OPT_Xpreprocessor);
182 }
183
184 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
185 Job &Dest,
186 const InputInfo &Output,
187 const InputInfoList &Inputs,
188 const ArgList &Args,
189 const char *LinkingOutput) const {
190 const Driver &D = getToolChain().getHost().getDriver();
191 ArgStringList CmdArgs;
192
193 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
194
195 CmdArgs.push_back("-triple");
196 const char *TripleStr =
197 Args.MakeArgString(getToolChain().getTripleString().c_str());
198 CmdArgs.push_back(TripleStr);
199
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");
206 else
207 CmdArgs.push_back("-E");
208 } else if (isa<PrecompileJobAction>(JA)) {
209 if (D.CCCUsePCH)
210 CmdArgs.push_back("-emit-pch");
211 else
212 CmdArgs.push_back("-emit-pth");
213 } else {
214 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
215
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");
224 }
225 }
226
227 // The make clang go fast button.
228 CmdArgs.push_back("-disable-free");
229
230 // Set the main file name, so that debug info works even with
231 // -save-temps.
232 CmdArgs.push_back("-main-file-name");
233 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
234
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");
239
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");
250 }
251
252 // Set the output format. The default is plist, for (lame) historical
253 // reasons.
254 CmdArgs.push_back("-analyzer-output");
255 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
256 CmdArgs.push_back(A->getValue(Args));
257 else
258 CmdArgs.push_back("plist");
259
260 // Add -Xanalyzer arguments when running as analyzer.
261 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
262 }
263
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.
269 //
270 // FIXME: This is currently broken for -f flags when -fno
271 // variants are present.
272
273 // This comes from the default translation the driver + cc1
274 // would do to enable flag_pic.
275 //
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();
284 if (!Model) {
285 if (Args.hasArg(options::OPT_mdynamic_no_pic))
286 Model = "dynamic-no-pic";
287 else if (PICDisabled)
288 Model = "static";
289 else if (PICEnabled)
290 Model = "pic";
291 else
292 Model = getToolChain().GetDefaultRelocationModel();
293 }
294 CmdArgs.push_back("--relocation-model");
295 CmdArgs.push_back(Model);
296
297 // Infer the __PIC__ value.
298 //
299 // FIXME: This isn't quite right on Darwin, which always sets
300 // __PIC__=2.
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");
304 else
305 CmdArgs.push_back("-pic-level=1");
306 }
307
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,
315 true))
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
324 // < 3)
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");
330 else
331 CmdArgs.push_back("--unwind-tables=0");
332 if (!Args.hasFlag(options::OPT_mred_zone,
333 options::OPT_mno_red_zone,
334 true) ||
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,
340 false))
341 CmdArgs.push_back("--no-implicit-float");
342
343 // FIXME: Handle -mtune=.
344 (void) Args.hasArg(options::OPT_mtune_EQ);
345
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));
351 } else {
352 // Select default CPU.
353
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");
360 } else {
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");
365 }
366 }
367
368 // FIXME: Use iterator.
369 for (ArgList::const_iterator
370 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
371 const Arg *A = *it;
372 if (A->getOption().matches(options::OPT_m_x86_Features_Group)) {
373 const char *Name = A->getOption().getName();
374
375 // Skip over "-m".
376 assert(Name[0] == '-' && Name[1] == 'm' && "Invalid feature name.");
377 Name += 2;
378
379 bool IsNegative = memcmp(Name, "no-", 3) == 0;
380 if (IsNegative)
381 Name += 3;
382
383 A->claim();
384 CmdArgs.push_back("-target-feature");
385 CmdArgs.push_back(MakeFormattedString(Args,
386 llvm::format("%c%s",
387 IsNegative ? '-' : '+',
388 Name)));
389 }
390 }
391
392 if (Args.hasFlag(options::OPT_fmath_errno,
393 options::OPT_fno_math_errno,
394 getToolChain().IsMathErrnoDefault()))
395 CmdArgs.push_back("--fmath-errno=1");
396 else
397 CmdArgs.push_back("--fmath-errno=0");
398
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));
402 }
403
404 // FIXME: Add --stack-protector-buffer-size=<xxx> on
405 // -fstack-protect.
406
407 Arg *Unsupported;
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();
413
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);
419
420 // Special case debug options to only pass -g to clang. This is
421 // wrong.
422 if (Args.hasArg(options::OPT_g_Group))
423 CmdArgs.push_back("-g");
424
425 Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
426
427 Args.AddLastArg(CmdArgs, options::OPT_isysroot);
428
429 // Add preprocessing options like -I, -D, etc. if we are using the
430 // preprocessor.
431 //
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);
436
437 // Manually translate -O to -O1 and -O4 to -O3; let clang reject
438 // others.
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");
444 else
445 A->render(Args, CmdArgs);
446 }
447
448 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
449 Args.AddLastArg(CmdArgs, options::OPT_w);
450
451 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
452 // (-ansi is equivalent to -std=c89).
453 //
454 // If a std is supplied, only add -trigraphs if it follows the
455 // option.
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");
459 else
460 Std->render(Args, CmdArgs);
461
462 if (Arg *A = Args.getLastArg(options::OPT_trigraphs))
463 if (A->getIndex() > Std->getIndex())
464 A->render(Args, CmdArgs);
465 } else {
466 // Honor -std-default.
467 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
468 "-std=", /*Joined=*/true);
469 Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
470 }
471
472 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
473 CmdArgs.push_back("-ftemplate-depth");
474 CmdArgs.push_back(A->getValue(Args));
475 }
476
477 if (Args.hasArg(options::OPT__relocatable_pch, true))
478 CmdArgs.push_back("--relocatable-pch");
479
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);
503
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");
512 else
513 CmdArgs.push_back("--stack-protector=2");
514 }
515
516 // Forward -f options with positive and negative forms; we translate
517 // these by hand.
518
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");
522
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");
528 else
529 CmdArgs.push_back("-fblocks=0");
530 }
531
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");
538 else
539 CmdArgs.push_back("-fsigned-char=0");
540 }
541
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.
545 //
546 // FIXME: This is gross; that translation should be pulled from the
547 // tool chain.
548 if (Args.hasFlag(options::OPT_fpascal_strings,
549 options::OPT_fno_pascal_strings,
550 false) ||
551 Args.hasFlag(options::OPT_mpascal_strings,
552 options::OPT_mno_pascal_strings,
553 false))
554 CmdArgs.push_back("-fpascal-strings");
555
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");
559
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);
566
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");
571
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");
582
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");
589 else
590 CmdArgs.push_back("-fdollars-in-identifiers=0");
591 }
592
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);
599 }
600
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);
604
605 Args.AddLastArg(CmdArgs, options::OPT_dM);
606 Args.AddLastArg(CmdArgs, options::OPT_dD);
607
608 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
609 Args.AddAllArgValues(CmdArgs, options::OPT_mllvm);
610
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());
619 } else {
620 assert(Output.isNothing() && "Invalid output.");
621 }
622
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()));
628 if (II.isPipe())
629 CmdArgs.push_back("-");
630 else if (II.isFilename())
631 CmdArgs.push_back(II.getFilename());
632 else
633 II.getInputArg().renderAsInput(Args, CmdArgs);
634 }
635
636 const char *Exec =
637 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang-cc").c_str());
638 Dest.addCommand(new Command(JA, Exec, CmdArgs));
639
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) {
645 const Arg *A = *it;
646 if (A->getOption().matches(options::OPT_pg)) {
647 A->claim();
648 D.Diag(clang::diag::warn_drv_clang_unsupported)
649 << A->getAsString(Args);
650 }
651 }
652
653 // Claim some arguments which clang supports automatically.
654
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
658 // -all.
659 Args.ClaimAllArgs(options::OPT_fpch_preprocess);
660
661 // Claim some arguments which clang doesn't support, but we don't
662 // care to warn the user about.
663
664 // FIXME: Use iterator.
665 for (ArgList::const_iterator
666 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
667 const Arg *A = *it;
668 if (A->getOption().matches(options::OPT_clang_ignored_f_Group) ||
669 A->getOption().matches(options::OPT_clang_ignored_m_Group))
670 A->claim();
671 }
672 }
673
674 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
675 Job &Dest,
676 const InputInfo &Output,
677 const InputInfoList &Inputs,
678 const ArgList &Args,
679 const char *LinkingOutput) const {
680 const Driver &D = getToolChain().getHost().getDriver();
681 ArgStringList CmdArgs;
682
683 for (ArgList::const_iterator
684 it = Args.begin(), ie = Args.end(); it != ie; ++it) {
685 Arg *A = *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.
691 A->claim();
692 A->render(Args, CmdArgs);
693 }
694 }
695
696 RenderExtraToolArgs(CmdArgs);
697
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");
702
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");
708 else
709 CmdArgs.push_back(Args.MakeArgString(Arch.c_str()));
710 }
711
712 // Try to force gcc to match the tool chain we want, if we recognize
713 // the arch.
714 //
715 // FIXME: The triple class should directly provide the information we want
716 // here.
717 if (Arch == "i386" || Arch == "powerpc")
718 CmdArgs.push_back("-m32");
719 else if (Arch == "x86_64" || Arch == "powerpc64")
720 CmdArgs.push_back("-m64");
721
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());
728 } else {
729 assert(Output.isNothing() && "Unexpected output");
730 CmdArgs.push_back("-fsyntax-only");
731 }
732
733
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.
739 //
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;
745
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();
750
751 if (types::canTypeBeUserSpecified(II.getType())) {
752 CmdArgs.push_back("-x");
753 CmdArgs.push_back(types::getTypeName(II.getType()));
754 }
755
756 if (II.isPipe())
757 CmdArgs.push_back("-");
758 else if (II.isFilename())
759 CmdArgs.push_back(II.getFilename());
760 else
761 // Don't render as input, we need gcc to do the translations.
762 II.getInputArg().render(Args, CmdArgs);
763 }
764
765 const char *GCCName =
766 getToolChain().getHost().getDriver().CCCGenericGCCName.c_str();
767 const char *Exec =
768 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName).c_str());
769 Dest.addCommand(new Command(JA, Exec, CmdArgs));
770 }
771
772 void gcc::Preprocess::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
773 CmdArgs.push_back("-E");
774 }
775
776 void gcc::Precompile::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
777 // The type is good enough.
778 }
779
780 void gcc::Compile::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
781 CmdArgs.push_back("-S");
782 }
783
784 void gcc::Assemble::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
785 CmdArgs.push_back("-c");
786 }
787
788 void gcc::Link::RenderExtraToolArgs(ArgStringList &CmdArgs) const {
789 // The types are (hopefully) good enough.
790 }
791
792 const char *darwin::CC1::getCC1Name(types::ID Type) const {
793 switch (Type) {
794 default:
795 assert(0 && "Unexpected type for Darwin CC1 tool.");
796 case types::TY_Asm:
797 case types::TY_C: case types::TY_CHeader:
798 case types::TY_PP_C: case types::TY_PP_CHeader:
799 return "cc1";
800 case types::TY_ObjC: case types::TY_ObjCHeader:
801 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader:
802 return "cc1obj";
803 case types::TY_CXX: case types::TY_CXXHeader:
804 case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
805 return "cc1plus";
806 case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
807 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader:
808 return "cc1objplus";
809 }
810 }
811
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());
816 }
817
818 const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
819 const InputInfoList &Inputs) {
820 const char *Str = getBaseInputName(Args, Inputs);
821
822 if (const char *End = strchr(Str, '.'))
823 return Args.MakeArgString(std::string(Str, End).c_str());
824
825 return Str;
826 }
827
828 const char *
829 darwin::CC1::getDependencyFileName(const ArgList &Args,
830 const InputInfoList &Inputs) {
831 // FIXME: Think about this more.
832 std::string Res;
833
834 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
835 std::string Str(OutputOpt->getValue(Args));
836
837 Res = Str.substr(0, Str.rfind('.'));
838 } else
839 Res = darwin::CC1::getBaseInputStem(Args, Inputs);
840
841 return Args.MakeArgString((Res + ".d").c_str());
842 }
843
844 void darwin::CC1::AddCC1Args(const ArgList &Args,
845 ArgStringList &CmdArgs) const {
846 // Derived from cc1 spec.
847
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");
852
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.
856
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
865
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");
869 }
870
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();
875
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");
881
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";
886
887 AddCC1Args(Args, CmdArgs);
888
889 if (!Args.hasArg(options::OPT_Q))
890 CmdArgs.push_back("-quiet");
891
892 CmdArgs.push_back("-dumpbase");
893 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
894
895 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
896
897 Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
898 Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
899
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));
908 } else {
909 CmdArgs.push_back("-auxbase");
910 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
911 }
912
913 Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
914
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);
925 }
926
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);
932
933 // The driver treats -fsyntax-only specially.
934 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
935
936 Args.AddAllArgs(CmdArgs, options::OPT_undef);
937 if (Args.hasArg(options::OPT_Qn))
938 CmdArgs.push_back("-fno-ident");
939
940 // FIXME: This isn't correct.
941 //Args.AddLastArg(CmdArgs, options::OPT__help)
942 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
943
944 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
945
946 // FIXME: Still don't get what is happening here. Investigate.
947 Args.AddAllArgs(CmdArgs, options::OPT__param);
948
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");
953 }
954
955 if (Args.hasArg(options::OPT_coverage)) {
956 CmdArgs.push_back("-fprofile-arcs");
957 CmdArgs.push_back("-ftest-coverage");
958 }
959
960 if (types::isCXX(Inputs[0].getType()))
961 CmdArgs.push_back("-D__private_extern__=extern");
962 }
963
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);
969
970 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
971
972 AddCC1Args(Args, CmdArgs);
973
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
977 // compatibility.
978
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);
986 }
987 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
988 Args.AddLastArg(CmdArgs, options::OPT_w);
989
990 // The driver treats -fsyntax-only specially.
991 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
992
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");
996
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");
1001 }
1002
1003 void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
1004 ArgStringList &CmdArgs,
1005 const InputInfoList &Inputs) const
1006 {
1007 const Driver &D = getToolChain().getHost().getDriver();
1008
1009 // Derived from cpp_unique_options.
1010 Arg *A;
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";
1016 }
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);
1023
1024 // FIXME: Handle %I properly.
1025 if (getToolChain().getArchName() == "x86_64") {
1026 CmdArgs.push_back("-imultilib");
1027 CmdArgs.push_back("x86_64");
1028 }
1029
1030 if (Args.hasArg(options::OPT_MD)) {
1031 CmdArgs.push_back("-MD");
1032 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
1033 }
1034
1035 if (Args.hasArg(options::OPT_MMD)) {
1036 CmdArgs.push_back("-MMD");
1037 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
1038 }
1039
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));
1052 }
1053 }
1054
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);
1059
1060 AddCPPArgs(Args, CmdArgs);
1061
1062 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
1063 Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
1064
1065 for (InputInfoList::const_iterator
1066 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1067 const InputInfo &II = *it;
1068
1069 if (II.isPipe())
1070 CmdArgs.push_back("-");
1071 else
1072 CmdArgs.push_back(II.getFilename());
1073 }
1074
1075 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1076 options::OPT_Xpreprocessor);
1077
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");
1082 }
1083
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");
1089 }
1090 }
1091
1092 void darwin::CC1::AddCPPArgs(const ArgList &Args,
1093 ArgStringList &CmdArgs) const {
1094 // Derived from cpp spec.
1095
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.
1099
1100 // if (!Args.hasArg(arglist.parser.dynamicOption))
1101 CmdArgs.push_back("-D__STATIC__");
1102 } else
1103 CmdArgs.push_back("-D__DYNAMIC__");
1104
1105 if (Args.hasArg(options::OPT_pthread))
1106 CmdArgs.push_back("-D_REENTRANT");
1107 }
1108
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;
1115
1116 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
1117
1118 CmdArgs.push_back("-E");
1119
1120 if (Args.hasArg(options::OPT_traditional) ||
1121 Args.hasArg(options::OPT_traditional_cpp))
1122 CmdArgs.push_back("-traditional-cpp");
1123
1124 ArgStringList OutputArgs;
1125 if (Output.isFilename()) {
1126 OutputArgs.push_back("-o");
1127 OutputArgs.push_back(Output.getFilename());
1128 } else {
1129 assert(Output.isPipe() && "Unexpected CC1 output.");
1130 }
1131
1132 if (Args.hasArg(options::OPT_E)) {
1133 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
1134 } else {
1135 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
1136 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
1137 }
1138
1139 Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
1140
1141 const char *CC1Name = getCC1Name(Inputs[0].getType());
1142 const char *Exec =
1143 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str());
1144 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1145 }
1146
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;
1154
1155 assert(Inputs.size() == 1 && "Unexpected number of inputs!");
1156
1157 types::ID InputType = Inputs[0].getType();
1158 const Arg *A;
1159 if ((A = Args.getLastArg(options::OPT_traditional)))
1160 D.Diag(clang::diag::err_drv_argument_only_allowed_with)
1161 << A->getAsString(Args) << "-E";
1162
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");
1167
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");
1175 else
1176 OutputArgs.push_back(Output.getFilename());
1177 }
1178
1179 // There is no need for this level of compatibility, but it makes
1180 // diffing easier.
1181 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
1182 Args.hasArg(options::OPT_S));
1183
1184 if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
1185 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
1186 if (OutputArgsEarly) {
1187 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
1188 } else {
1189 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
1190 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
1191 }
1192 } else {
1193 CmdArgs.push_back("-fpreprocessed");
1194
1195 // FIXME: There is a spec command to remove
1196 // -fpredictive-compilation args here. Investigate.
1197
1198 for (InputInfoList::const_iterator
1199 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1200 const InputInfo &II = *it;
1201
1202 if (II.isPipe())
1203 CmdArgs.push_back("-");
1204 else
1205 CmdArgs.push_back(II.getFilename());
1206 }
1207
1208 if (OutputArgsEarly) {
1209 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
1210 } else {
1211 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
1212 CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
1213 }
1214 }
1215
1216 if (Output.getType() == types::TY_PCH) {
1217 assert(Output.isFilename() && "Invalid PCH output.");
1218
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");
1223
1224 CmdArgs.push_back("--output-pch=");
1225 CmdArgs.push_back(Output.getFilename());
1226 }
1227
1228 const char *CC1Name = getCC1Name(Inputs[0].getType());
1229 const char *Exec =
1230 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str());
1231 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1232 }
1233
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;
1240
1241 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
1242 const InputInfo &Input = Inputs[0];
1243
1244 // Bit of a hack, this is only used for original inputs.
1245 //
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");
1253 }
1254
1255 // Derived from asm spec.
1256 CmdArgs.push_back("-arch");
1257 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName().c_str()));
1258
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");
1265
1266 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
1267 options::OPT_Xassembler);
1268
1269 assert(Output.isFilename() && "Unexpected lipo output.");
1270 CmdArgs.push_back("-o");
1271 CmdArgs.push_back(Output.getFilename());
1272
1273 if (Input.isPipe()) {
1274 CmdArgs.push_back("-");
1275 } else {
1276 assert(Input.isFilename() && "Invalid input.");
1277 CmdArgs.push_back(Input.getFilename());
1278 }
1279
1280 // asm_final spec is empty.
1281
1282 const char *Exec =
1283 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str());
1284 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1285 }
1286
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',
1292 // 'mm'.
1293 switch (strlen(Str)) {
1294 default:
1295 return false;
1296 case 1:
1297 return (memcmp(Str, "C", 1) == 0 ||
1298 memcmp(Str, "c", 1) == 0 ||
1299 memcmp(Str, "m", 1) == 0);
1300 case 2:
1301 return (memcmp(Str, "cc", 2) == 0 ||
1302 memcmp(Str, "cp", 2) == 0 ||
1303 memcmp(Str, "mm", 2) == 0);
1304 case 3:
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);
1309 }
1310 }
1311
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;
1316 }
1317 return false;
1318 }
1319
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);
1324 }
1325
1326 const toolchains::Darwin_X86 &darwin::Link::getDarwinToolChain() const {
1327 return reinterpret_cast<const toolchains::Darwin_X86&>(getToolChain());
1328 }
1329
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()));
1335 }
1336
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);
1342 }
1343
1344 void darwin::Link::AddLinkArgs(const ArgList &Args,
1345 ArgStringList &CmdArgs) const {
1346 const Driver &D = getToolChain().getHost().getDriver();
1347
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?
1355 }
1356
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");
1361 } else
1362 AddDarwinSubArch(Args, CmdArgs);
1363
1364 Args.AddLastArg(CmdArgs, options::OPT_bundle);
1365 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
1366 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
1367
1368 Arg *A;
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";
1374
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);
1378 } else {
1379 CmdArgs.push_back("-dylib");
1380
1381 Arg *A;
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";
1390
1391 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
1392 "-dylib_compatibility_version");
1393 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
1394 "-dylib_current_version");
1395
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.
1399 } else
1400 AddDarwinSubArch(Args, CmdArgs);
1401
1402 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
1403 "-dylib_install_name");
1404 }
1405
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);
1418
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
1424 // somewhere.
1425 CmdArgs.push_back("-macosx_version_min");
1426 CmdArgs.push_back(getDarwinToolChain().getMacosxVersionStr());
1427 }
1428 } else {
1429 // Adding all arguments doesn't make sense here but this is what
1430 // gcc does.
1431 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ,
1432 "-macosx_version_min");
1433 }
1434
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);
1442
1443 if (Args.hasArg(options::OPT_fpie))
1444 CmdArgs.push_back("-pie");
1445
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);
1469
1470 if (!Args.hasArg(options::OPT_weak__reference__mismatches)) {
1471 CmdArgs.push_back("-weak_reference_mismatches");
1472 CmdArgs.push_back("non-weak");
1473 }
1474
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);
1490 }
1491
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.
1501
1502 // FIXME: The spec references -fdump= which seems to have
1503 // disappeared?
1504
1505 ArgStringList CmdArgs;
1506
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);
1510
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);
1521
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);
1526
1527 CmdArgs.push_back("-o");
1528 CmdArgs.push_back(Output.getFilename());
1529
1530 unsigned MacosxVersion[3];
1531 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) {
1532 bool HadExtra;
1533 if (!Driver::GetReleaseVersion(A->getValue(Args), MacosxVersion[0],
1534 MacosxVersion[1], MacosxVersion[2],
1535 HadExtra) ||
1536 HadExtra) {
1537 const Driver &D = getToolChain().getHost().getDriver();
1538 D.Diag(clang::diag::err_drv_invalid_version_number)
1539 << A->getAsString(Args);
1540 }
1541 } else {
1542 getDarwinToolChain().getMacosxVersion(MacosxVersion);
1543 }
1544
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");
1555 } else {
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");
1561 }
1562 } else {
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");
1568 } else {
1569 CmdArgs.push_back("-lgcrt1.o");
1570
1571 // darwin_crt2 spec is empty.
1572 }
1573 } else {
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");
1578 } else {
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");
1584 else
1585 CmdArgs.push_back("-lcrt1.10.6.o");
1586
1587 // darwin_crt2 spec is empty.
1588 }
1589 }
1590 }
1591 }
1592
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));
1598 }
1599 }
1600
1601 Args.AddAllArgs(CmdArgs, options::OPT_L);
1602
1603 if (Args.hasArg(options::OPT_fopenmp))
1604 // This is more complicated in gcc...
1605 CmdArgs.push_back("-lgomp");
1606
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)));
1615 }
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)));
1627
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());
1633 else
1634 II.getInputArg().renderAsInput(Args, CmdArgs);
1635 }
1636
1637 if (LinkingOutput) {
1638 CmdArgs.push_back("-arch_multiple");
1639 CmdArgs.push_back("-final_output");
1640 CmdArgs.push_back(LinkingOutput);
1641 }
1642
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");
1648
1649 if (Args.hasArg(options::OPT_fnested_functions))
1650 CmdArgs.push_back("-allow_stack_execute");
1651
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++");
1658
1659 // link_ssp spec is empty.
1660
1661 // Derived from libgcc and lib specs but refactored.
1662 if (Args.hasArg(options::OPT_static)) {
1663 CmdArgs.push_back("-lgcc_static");
1664 } else {
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");
1678 } else {
1679 if (isMacosxVersionLT(MacosxVersion, 10, 3, 9))
1680 ; // Do nothing.
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");
1685 }
1686
1687 if (isMacosxVersionLT(MacosxVersion, 10, 6)) {
1688 CmdArgs.push_back("-lgcc");
1689 CmdArgs.push_back("-lSystem");
1690 } else {
1691 CmdArgs.push_back("-lSystem");
1692 CmdArgs.push_back("-lgcc");
1693 }
1694 }
1695 }
1696
1697 if (!Args.hasArg(options::OPT_A) &&
1698 !Args.hasArg(options::OPT_nostdlib) &&
1699 !Args.hasArg(options::OPT_nostartfiles)) {
1700 // endfile_spec is empty.
1701 }
1702
1703 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
1704 Args.AddAllArgs(CmdArgs, options::OPT_F);
1705
1706 const char *Exec =
1707 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str());
1708 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1709
1710 // Find the first non-empty base input (we want to ignore linker
1711 // inputs).
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();
1716 break;
1717 }
1718 }
1719
1720 // Run dsymutil if we are making an executable in a single step.
1721 //
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
1724 // files.
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)) {
1734 const char *Exec =
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));
1739 }
1740 }
1741 }
1742
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;
1749
1750 CmdArgs.push_back("-create");
1751 assert(Output.isFilename() && "Unexpected lipo output.");
1752
1753 CmdArgs.push_back("-output");
1754 CmdArgs.push_back(Output.getFilename());
1755
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());
1761 }
1762 const char *Exec =
1763 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo").c_str());
1764 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1765 }
1766
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
1772 {
1773 ArgStringList CmdArgs;
1774
1775 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
1776 options::OPT_Xassembler);
1777
1778 CmdArgs.push_back("-o");
1779 if (Output.isPipe())
1780 CmdArgs.push_back("-");
1781 else
1782 CmdArgs.push_back(Output.getFilename());
1783
1784 for (InputInfoList::const_iterator
1785 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1786 const InputInfo &II = *it;
1787 if (II.isPipe())
1788 CmdArgs.push_back("-");
1789 else
1790 CmdArgs.push_back(II.getFilename());
1791 }
1792
1793 const char *Exec =
1794 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str());
1795 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1796 }
1797
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;
1805
1806 if (Args.hasArg(options::OPT_static)) {
1807 CmdArgs.push_back("-Bstatic");
1808 } else {
1809 CmdArgs.push_back("--eh-frame-hdr");
1810 if (Args.hasArg(options::OPT_shared)) {
1811 CmdArgs.push_back("-Bshareable");
1812 } else {
1813 CmdArgs.push_back("-dynamic-linker");
1814 CmdArgs.push_back("/usr/libexec/ld.so");
1815 }
1816 }
1817
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());
1824 } else {
1825 assert(Output.isNothing() && "Invalid output.");
1826 }
1827
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()));
1833 } else {
1834 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o").c_str()));
1835 }
1836 }
1837
1838 Args.AddAllArgs(CmdArgs, options::OPT_L);
1839 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
1840 Args.AddAllArgs(CmdArgs, options::OPT_e);
1841
1842 for (InputInfoList::const_iterator
1843 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1844 const InputInfo &II = *it;
1845
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();
1850
1851 if (II.isPipe())
1852 CmdArgs.push_back("-");
1853 else if (II.isFilename())
1854 CmdArgs.push_back(II.getFilename());
1855 else
1856 II.getInputArg().renderAsInput(Args, CmdArgs);
1857 }
1858
1859 if (!Args.hasArg(options::OPT_nostdlib) &&
1860 !Args.hasArg(options::OPT_nodefaultlibs)) {
1861
1862 if (Args.hasArg(options::OPT_pthread))
1863 CmdArgs.push_back("-pthread");
1864 CmdArgs.push_back("-lc");
1865 }
1866
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()));
1871 else
1872 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o").c_str()));
1873 }
1874
1875 const char *Exec =
1876 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str());
1877 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1878 }
1879
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
1885 {
1886 ArgStringList CmdArgs;
1887
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");
1892
1893 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
1894 options::OPT_Xassembler);
1895
1896 CmdArgs.push_back("-o");
1897 if (Output.isPipe())
1898 CmdArgs.push_back("-");
1899 else
1900 CmdArgs.push_back(Output.getFilename());
1901
1902 for (InputInfoList::const_iterator
1903 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1904 const InputInfo &II = *it;
1905 if (II.isPipe())
1906 CmdArgs.push_back("-");
1907 else
1908 CmdArgs.push_back(II.getFilename());
1909 }
1910
1911 const char *Exec =
1912 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str());
1913 Dest.addCommand(new Command(JA, Exec, CmdArgs));
1914 }
1915
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;
1923
1924 if (Args.hasArg(options::OPT_static)) {
1925 CmdArgs.push_back("-Bstatic");
1926 } else {
1927 CmdArgs.push_back("--eh-frame-hdr");
1928 if (Args.hasArg(options::OPT_shared)) {
1929 CmdArgs.push_back("-Bshareable");
1930 } else {
1931 CmdArgs.push_back("-dynamic-linker");
1932 CmdArgs.push_back("/libexec/ld-elf.so.1");
1933 }
1934 }
1935
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");
1941 }
1942
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());
1949 } else {
1950 assert(Output.isNothing() && "Invalid output.");
1951 }
1952
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()));
1959 } else {
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()));
1962 }
1963 }
1964
1965 Args.AddAllArgs(CmdArgs, options::OPT_L);
1966 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
1967 Args.AddAllArgs(CmdArgs, options::OPT_e);
1968
1969 for (InputInfoList::const_iterator
1970 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
1971 const InputInfo &II = *it;
1972
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();
1977
1978 if (II.isPipe())
1979 CmdArgs.push_back("-");
1980 else if (II.isFilename())
1981 CmdArgs.push_back(II.getFilename());
1982 else
1983 II.getInputArg().renderAsInput(Args, CmdArgs);
1984 }
1985
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");
1993 } else {
1994 CmdArgs.push_back("--as-needed");
1995 CmdArgs.push_back("-lgcc_s");
1996 CmdArgs.push_back("--no-as-needed");
1997 }
1998
1999 if (Args.hasArg(options::OPT_pthread))
2000 CmdArgs.push_back("-lpthread");
2001 CmdArgs.push_back("-lc");
2002
2003 CmdArgs.push_back("-lgcc");
2004 if (Args.hasArg(options::OPT_static)) {
2005 CmdArgs.push_back("-lgcc_eh");
2006 } else {
2007 CmdArgs.push_back("--as-needed");
2008 CmdArgs.push_back("-lgcc_s");
2009 CmdArgs.push_back("--no-as-needed");
2010 }
2011 }
2012
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()));
2017 else
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()));
2020 }
2021
2022 const char *Exec =
2023 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str());
2024 Dest.addCommand(new Command(JA, Exec, CmdArgs));
2025 }
2026
2027 /// DragonFly Tools
2028
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;
2037
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");
2042
2043 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2044 options::OPT_Xassembler);
2045
2046 CmdArgs.push_back("-o");
2047 if (Output.isPipe())
2048 CmdArgs.push_back("-");
2049 else
2050 CmdArgs.push_back(Output.getFilename());
2051
2052 for (InputInfoList::const_iterator
2053 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2054 const InputInfo &II = *it;
2055 if (II.isPipe())
2056 CmdArgs.push_back("-");
2057 else
2058 CmdArgs.push_back(II.getFilename());
2059 }
2060
2061 const char *Exec =
2062 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str());
2063 Dest.addCommand(new Command(JA, Exec, CmdArgs));
2064 }
2065
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;
2073
2074 if (Args.hasArg(options::OPT_static)) {
2075 CmdArgs.push_back("-Bstatic");
2076 } else {
2077 if (Args.hasArg(options::OPT_shared))
2078 CmdArgs.push_back("-Bshareable");
2079 else {
2080 CmdArgs.push_back("-dynamic-linker");
2081 CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
2082 }
2083 }
2084
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");
2090 }
2091
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());
2098 } else {
2099 assert(Output.isNothing() && "Invalid output.");
2100 }
2101
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()));
2108 } else {
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()));
2111 }
2112 }
2113
2114 Args.AddAllArgs(CmdArgs, options::OPT_L);
2115 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
2116 Args.AddAllArgs(CmdArgs, options::OPT_e);
2117
2118 for (InputInfoList::const_iterator
2119 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2120 const InputInfo &II = *it;
2121
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();
2126
2127 if (II.isPipe())
2128 CmdArgs.push_back("-");
2129 else if (II.isFilename())
2130 CmdArgs.push_back(II.getFilename());
2131 else
2132 II.getInputArg().renderAsInput(Args, CmdArgs);
2133 }
2134
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
2138 // rpaths
2139 CmdArgs.push_back("-L/usr/lib/gcc41");
2140
2141 if (!Args.hasArg(options::OPT_static)) {
2142 CmdArgs.push_back("-rpath");
2143 CmdArgs.push_back("/usr/lib/gcc41");
2144
2145 CmdArgs.push_back("-rpath-link");
2146 CmdArgs.push_back("/usr/lib/gcc41");
2147
2148 CmdArgs.push_back("-rpath");
2149 CmdArgs.push_back("/usr/lib");
2150
2151 CmdArgs.push_back("-rpath-link");
2152 CmdArgs.push_back("/usr/lib");
2153 }
2154
2155 if (Args.hasArg(options::OPT_shared)) {
2156 CmdArgs.push_back("-lgcc_pic");
2157 } else {
2158 CmdArgs.push_back("-lgcc");
2159 }
2160
2161
2162 if (Args.hasArg(options::OPT_pthread))
2163 CmdArgs.push_back("-lthread_xu");
2164
2165 if (!Args.hasArg(options::OPT_nolibc)) {
2166 CmdArgs.push_back("-lc");
2167 }
2168
2169 if (Args.hasArg(options::OPT_shared)) {
2170 CmdArgs.push_back("-lgcc_pic");
2171 } else {
2172 CmdArgs.push_back("-lgcc");
2173 }
2174 }
2175
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()));
2180 else
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()));
2183 }
2184
2185 const char *Exec =
2186 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str());
2187 Dest.addCommand(new Command(JA, Exec, CmdArgs));
2188 }
ACC - The Annoying C Compiler