Tools.cpp revision a67ac1e5d9f51606b13c5ce7f0052cd33b8fd056
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 31using namespace clang::driver; 32using namespace clang::driver::tools; 33 34static 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 41void Clang::AddPreprocessingOptions(const Driver &D, 42 const ArgList &Args, 43 ArgStringList &CmdArgs, 44 const InputInfo &Output, 45 const InputInfoList &Inputs) const { 46 // Handle dependency file generation. 47 Arg *A; 48 if ((A = Args.getLastArg(options::OPT_M)) || 49 (A = Args.getLastArg(options::OPT_MM)) || 50 (A = Args.getLastArg(options::OPT_MD)) || 51 (A = Args.getLastArg(options::OPT_MMD))) { 52 // Determine the output location. 53 const char *DepFile; 54 if (Output.getType() == types::TY_Dependencies) { 55 if (Output.isPipe()) 56 DepFile = "-"; 57 else 58 DepFile = Output.getFilename(); 59 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 60 DepFile = MF->getValue(Args); 61 } else if (A->getOption().getId() == options::OPT_M || 62 A->getOption().getId() == options::OPT_MM) { 63 DepFile = "-"; 64 } else { 65 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 66 } 67 CmdArgs.push_back("-dependency-file"); 68 CmdArgs.push_back(DepFile); 69 70 // Add an -MT option if the user didn't specify their own. 71 // FIXME: This should use -MQ, when we support it. 72 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 73 const char *DepTarget; 74 75 // If user provided -o, that is the dependency target, except 76 // when we are only generating a dependency file. 77 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 78 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 79 DepTarget = OutputOpt->getValue(Args); 80 } else { 81 // Otherwise derive from the base input. 82 // 83 // FIXME: This should use the computed output file location. 84 llvm::sys::Path P(Inputs[0].getBaseInput()); 85 86 P.eraseSuffix(); 87 P.appendSuffix("o"); 88 DepTarget = Args.MakeArgString(P.getLast().c_str()); 89 } 90 91 CmdArgs.push_back("-MT"); 92 CmdArgs.push_back(DepTarget); 93 } 94 95 if (A->getOption().getId() == options::OPT_M || 96 A->getOption().getId() == options::OPT_MD) 97 CmdArgs.push_back("-sys-header-deps"); 98 } 99 100 Args.AddLastArg(CmdArgs, options::OPT_MP); 101 Args.AddAllArgs(CmdArgs, options::OPT_MT); 102 103 // FIXME: Use iterator. 104 105 // Add -i* options, and automatically translate to 106 // -include-pch/-include-pth for transparent PCH support. It's 107 // wonky, but we include looking for .gch so we can support seamless 108 // replacement into a build system already set up to be generating 109 // .gch files. 110 for (ArgList::const_iterator 111 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 112 const Arg *A = *it; 113 if (!A->getOption().matches(options::OPT_clang_i_Group)) 114 continue; 115 116 if (A->getOption().matches(options::OPT_include)) { 117 bool FoundPTH = false; 118 bool FoundPCH = false; 119 llvm::sys::Path P(A->getValue(Args)); 120 if (D.CCCUsePCH) { 121 P.appendSuffix("pch"); 122 if (P.exists()) 123 FoundPCH = true; 124 else 125 P.eraseSuffix(); 126 } 127 128 if (!FoundPCH) { 129 P.appendSuffix("pth"); 130 if (P.exists()) 131 FoundPTH = true; 132 else 133 P.eraseSuffix(); 134 } 135 136 if (!FoundPCH && !FoundPTH) { 137 P.appendSuffix("gch"); 138 if (P.exists()) { 139 FoundPCH = D.CCCUsePCH; 140 FoundPTH = !D.CCCUsePCH; 141 } 142 else 143 P.eraseSuffix(); 144 } 145 146 if (FoundPCH || FoundPTH) { 147 A->claim(); 148 if (D.CCCUsePCH) 149 CmdArgs.push_back("-include-pch"); 150 else 151 CmdArgs.push_back("-include-pth"); 152 CmdArgs.push_back(Args.MakeArgString(P.c_str())); 153 continue; 154 } 155 } 156 157 // Not translated, render as usual. 158 A->claim(); 159 A->render(Args, CmdArgs); 160 } 161 162 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 163 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 164 165 // Add -Wp, and -Xassembler if using the preprocessor. 166 167 // FIXME: There is a very unfortunate problem here, some troubled 168 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 169 // really support that we would have to parse and then translate 170 // those options. :( 171 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 172 options::OPT_Xpreprocessor); 173} 174 175void Clang::ConstructJob(Compilation &C, const JobAction &JA, 176 Job &Dest, 177 const InputInfo &Output, 178 const InputInfoList &Inputs, 179 const ArgList &Args, 180 const char *LinkingOutput) const { 181 const Driver &D = getToolChain().getHost().getDriver(); 182 ArgStringList CmdArgs; 183 184 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 185 186 CmdArgs.push_back("-triple"); 187 const char *TripleStr = 188 Args.MakeArgString(getToolChain().getTripleString().c_str()); 189 CmdArgs.push_back(TripleStr); 190 191 if (isa<AnalyzeJobAction>(JA)) { 192 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 193 CmdArgs.push_back("-analyze"); 194 } else if (isa<PreprocessJobAction>(JA)) { 195 if (Output.getType() == types::TY_Dependencies) 196 CmdArgs.push_back("-Eonly"); 197 else 198 CmdArgs.push_back("-E"); 199 } else if (isa<PrecompileJobAction>(JA)) { 200 if (D.CCCUsePCH) 201 CmdArgs.push_back("-emit-pch"); 202 else 203 CmdArgs.push_back("-emit-pth"); 204 } else { 205 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 206 207 if (JA.getType() == types::TY_Nothing) { 208 CmdArgs.push_back("-fsyntax-only"); 209 } else if (JA.getType() == types::TY_LLVMAsm) { 210 CmdArgs.push_back("-emit-llvm"); 211 } else if (JA.getType() == types::TY_LLVMBC) { 212 CmdArgs.push_back("-emit-llvm-bc"); 213 } else if (JA.getType() == types::TY_PP_Asm) { 214 CmdArgs.push_back("-S"); 215 } 216 } 217 218 // The make clang go fast button. 219 CmdArgs.push_back("-disable-free"); 220 221 // Set the main file name, so that debug info works even with 222 // -save-temps. 223 CmdArgs.push_back("-main-file-name"); 224 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 225 226 // Some flags which affect the language (via preprocessor 227 // defines). See darwin::CC1::AddCPPArgs. 228 if (Args.hasArg(options::OPT_static)) 229 CmdArgs.push_back("-static-define"); 230 231 if (isa<AnalyzeJobAction>(JA)) { 232 // Add default argument set. 233 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 234 CmdArgs.push_back("-warn-dead-stores"); 235 CmdArgs.push_back("-checker-cfref"); 236 CmdArgs.push_back("-analyzer-eagerly-assume"); 237 CmdArgs.push_back("-warn-objc-methodsigs"); 238 // Do not enable the missing -dealloc check. 239 // '-warn-objc-missing-dealloc', 240 CmdArgs.push_back("-warn-objc-unused-ivars"); 241 } 242 243 // Set the output format. The default is plist, for (lame) historical 244 // reasons. 245 CmdArgs.push_back("-analyzer-output"); 246 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 247 CmdArgs.push_back(A->getValue(Args)); 248 else 249 CmdArgs.push_back("plist"); 250 251 // Add -Xanalyzer arguments when running as analyzer. 252 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 253 } 254 255 // Perform argument translation for LLVM backend. This 256 // takes some care in reconciling with llvm-gcc. The 257 // issue is that llvm-gcc translates these options based on 258 // the values in cc1, whereas we are processing based on 259 // the driver arguments. 260 // 261 // FIXME: This is currently broken for -f flags when -fno 262 // variants are present. 263 264 // This comes from the default translation the driver + cc1 265 // would do to enable flag_pic. 266 // 267 // FIXME: Centralize this code. 268 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 269 Args.hasArg(options::OPT_fpic) || 270 Args.hasArg(options::OPT_fPIE) || 271 Args.hasArg(options::OPT_fpie)); 272 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 273 Args.hasArg(options::OPT_static)); 274 const char *Model = getToolChain().GetForcedPicModel(); 275 if (!Model) { 276 if (Args.hasArg(options::OPT_mdynamic_no_pic)) 277 Model = "dynamic-no-pic"; 278 else if (PICDisabled) 279 Model = "static"; 280 else if (PICEnabled) 281 Model = "pic"; 282 else 283 Model = getToolChain().GetDefaultRelocationModel(); 284 } 285 CmdArgs.push_back("--relocation-model"); 286 CmdArgs.push_back(Model); 287 288 // Infer the __PIC__ value. 289 // 290 // FIXME: This isn't quite right on Darwin, which always sets 291 // __PIC__=2. 292 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 293 if (Args.hasArg(options::OPT_fPIC)) 294 CmdArgs.push_back("-pic-level=2"); 295 else 296 CmdArgs.push_back("-pic-level=1"); 297 } 298 299 if (Args.hasArg(options::OPT_ftime_report)) 300 CmdArgs.push_back("--time-passes"); 301 // FIXME: Set --enable-unsafe-fp-math. 302 if (!Args.hasArg(options::OPT_fomit_frame_pointer)) 303 CmdArgs.push_back("--disable-fp-elim"); 304 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 305 options::OPT_fno_zero_initialized_in_bss, 306 true)) 307 CmdArgs.push_back("--nozero-initialized-in-bss"); 308 if (Args.hasArg(options::OPT_dA) || Args.hasArg(options::OPT_fverbose_asm)) 309 CmdArgs.push_back("--asm-verbose"); 310 if (Args.hasArg(options::OPT_fdebug_pass_structure)) 311 CmdArgs.push_back("--debug-pass=Structure"); 312 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) 313 CmdArgs.push_back("--debug-pass=Arguments"); 314 // FIXME: set --inline-threshhold=50 if (optimize_size || optimize 315 // < 3) 316 if (Args.hasFlag(options::OPT_funwind_tables, 317 options::OPT_fno_unwind_tables, 318 (getToolChain().IsUnwindTablesDefault() && 319 !Args.hasArg(options::OPT_mkernel)))) 320 CmdArgs.push_back("--unwind-tables=1"); 321 else 322 CmdArgs.push_back("--unwind-tables=0"); 323 if (!Args.hasFlag(options::OPT_mred_zone, 324 options::OPT_mno_red_zone, 325 true) || 326 Args.hasArg(options::OPT_mkernel) || 327 Args.hasArg(options::OPT_fapple_kext)) 328 CmdArgs.push_back("--disable-red-zone"); 329 if (Args.hasFlag(options::OPT_msoft_float, 330 options::OPT_mno_soft_float, 331 false)) 332 CmdArgs.push_back("--soft-float"); 333 334 // FIXME: Handle -mtune=. 335 (void) Args.hasArg(options::OPT_mtune_EQ); 336 337 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 338 // FIXME: We may need some translation here from the options gcc takes to 339 // names the LLVM backend understand? 340 CmdArgs.push_back("-mcpu"); 341 CmdArgs.push_back(A->getValue(Args)); 342 } else { 343 // Select default CPU. 344 345 // FIXME: Need target hooks. 346 if (memcmp(getToolChain().getOS().c_str(), "darwin", 6) == 0) { 347 if (getToolChain().getArchName() == "x86_64") 348 CmdArgs.push_back("--mcpu=core2"); 349 else if (getToolChain().getArchName() == "i386") 350 CmdArgs.push_back("--mcpu=yonah"); 351 } else { 352 if (getToolChain().getArchName() == "x86_64") 353 CmdArgs.push_back("--mcpu=x86-64"); 354 else if (getToolChain().getArchName() == "i386") 355 CmdArgs.push_back("--mcpu=pentium4"); 356 } 357 } 358 359 // FIXME: Use iterator. 360 for (ArgList::const_iterator 361 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 362 const Arg *A = *it; 363 if (A->getOption().matches(options::OPT_m_x86_Features_Group)) { 364 const char *Name = A->getOption().getName(); 365 366 // Skip over "-m". 367 assert(Name[0] == '-' && Name[1] == 'm' && "Invalid feature name."); 368 Name += 2; 369 370 bool IsNegative = memcmp(Name, "no-", 3) == 0; 371 if (IsNegative) 372 Name += 3; 373 374 A->claim(); 375 CmdArgs.push_back("-target-feature"); 376 CmdArgs.push_back(MakeFormattedString(Args, 377 llvm::format("%c%s", 378 IsNegative ? '-' : '+', 379 Name))); 380 } 381 } 382 383 if (Args.hasFlag(options::OPT_fmath_errno, 384 options::OPT_fno_math_errno, 385 getToolChain().IsMathErrnoDefault())) 386 CmdArgs.push_back("--fmath-errno=1"); 387 else 388 CmdArgs.push_back("--fmath-errno=0"); 389 390 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 391 CmdArgs.push_back("--limit-float-precision"); 392 CmdArgs.push_back(A->getValue(Args)); 393 } 394 395 // FIXME: Add --stack-protector-buffer-size=<xxx> on 396 // -fstack-protect. 397 398 Arg *Unsupported; 399 if ((Unsupported = Args.getLastArg(options::OPT_MG)) || 400 (Unsupported = Args.getLastArg(options::OPT_MQ)) || 401 (Unsupported = Args.getLastArg(options::OPT_iframework))) 402 D.Diag(clang::diag::err_drv_clang_unsupported) 403 << Unsupported->getOption().getName(); 404 405 Args.AddAllArgs(CmdArgs, options::OPT_v); 406 Args.AddLastArg(CmdArgs, options::OPT_P); 407 Args.AddLastArg(CmdArgs, options::OPT_mmacosx_version_min_EQ); 408 Args.AddLastArg(CmdArgs, options::OPT_miphoneos_version_min_EQ); 409 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 410 411 // Special case debug options to only pass -g to clang. This is 412 // wrong. 413 if (Args.hasArg(options::OPT_g_Group)) 414 CmdArgs.push_back("-g"); 415 416 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 417 418 Args.AddLastArg(CmdArgs, options::OPT_isysroot); 419 420 // Add preprocessing options like -I, -D, etc. if we are using the 421 // preprocessor. 422 // 423 // FIXME: Support -fpreprocessed 424 types::ID InputType = Inputs[0].getType(); 425 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 426 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 427 428 // Manually translate -O to -O1 and -O4 to -O3; let clang reject 429 // others. 430 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 431 if (A->getOption().getId() == options::OPT_O4) 432 CmdArgs.push_back("-O3"); 433 else if (A->getValue(Args)[0] == '\0') 434 CmdArgs.push_back("-O1"); 435 else 436 A->render(Args, CmdArgs); 437 } 438 439 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 440 Args.AddLastArg(CmdArgs, options::OPT_w); 441 442 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 443 // (-ansi is equivalent to -std=c89). 444 // 445 // If a std is supplied, only add -trigraphs if it follows the 446 // option. 447 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 448 if (Std->getOption().matches(options::OPT_ansi)) 449 CmdArgs.push_back("-std=c89"); 450 else 451 Std->render(Args, CmdArgs); 452 453 if (Arg *A = Args.getLastArg(options::OPT_trigraphs)) 454 if (A->getIndex() > Std->getIndex()) 455 A->render(Args, CmdArgs); 456 } else { 457 // Honor -std-default. 458 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 459 "-std=", /*Joined=*/true); 460 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 461 } 462 463 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 464 CmdArgs.push_back("-ftemplate-depth"); 465 CmdArgs.push_back(A->getValue(Args)); 466 } 467 468 // Forward -f options which we can pass directly. 469 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 470 Args.AddLastArg(CmdArgs, options::OPT_fexceptions); 471 Args.AddLastArg(CmdArgs, options::OPT_ffreestanding); 472 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 473 Args.AddLastArg(CmdArgs, options::OPT_fgnu_runtime); 474 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions); 475 Args.AddLastArg(CmdArgs, options::OPT_fmessage_length_EQ); 476 Args.AddLastArg(CmdArgs, options::OPT_fms_extensions); 477 Args.AddLastArg(CmdArgs, options::OPT_fnext_runtime); 478 Args.AddLastArg(CmdArgs, options::OPT_fno_caret_diagnostics); 479 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column); 480 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc_only); 481 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc); 482 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 483 // FIXME: Should we remove this? 484 Args.AddLastArg(CmdArgs, options::OPT_fobjc_nonfragile_abi); 485 Args.AddLastArg(CmdArgs, options::OPT_fobjc_tight_layout); 486 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 487 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 488 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 489 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_EQ); 490 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 491 492 // Forward -f options with positive and negative forms; we translate 493 // these by hand. 494 495 // -fbuiltin is default, only pass non-default. 496 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 497 CmdArgs.push_back("-fbuiltin=0"); 498 499 // -fblocks default varies depending on platform and language; only 500 // pass if specified. 501 if (Arg *A = Args.getLastArg(options::OPT_fblocks, options::OPT_fno_blocks)) { 502 if (A->getOption().matches(options::OPT_fblocks)) 503 CmdArgs.push_back("-fblocks"); 504 else 505 CmdArgs.push_back("-fblocks=0"); 506 } 507 508 // -fno-pascal-strings is default, only pass non-default. If the 509 // -tool chain happened to translate to -mpascal-strings, we want to 510 // -back translate here. 511 // 512 // FIXME: This is gross; that translation should be pulled from the 513 // tool chain. 514 if (Args.hasFlag(options::OPT_fpascal_strings, 515 options::OPT_fno_pascal_strings, 516 false) || 517 Args.hasFlag(options::OPT_mpascal_strings, 518 options::OPT_mno_pascal_strings, 519 false)) 520 CmdArgs.push_back("-fpascal-strings"); 521 522 // -fcommon is default, only pass non-default. 523 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 524 CmdArgs.push_back("-fno-common"); 525 526 // -fsigned-bitfields is default, and clang doesn't yet support 527 // --funsigned-bitfields. 528 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 529 options::OPT_funsigned_bitfields)) 530 D.Diag(clang::diag::warn_drv_clang_unsupported) 531 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 532 533 // -fdiagnostics-fixit-info is default, only pass non-default. 534 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 535 options::OPT_fno_diagnostics_fixit_info)) 536 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 537 538 // Enable -fdiagnostics-show-option by default. 539 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 540 options::OPT_fno_diagnostics_show_option)) 541 CmdArgs.push_back("-fdiagnostics-show-option"); 542 543 // -fdollars-in-identifiers default varies depending on platform and 544 // language; only pass if specified. 545 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 546 options::OPT_fno_dollars_in_identifiers)) { 547 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 548 CmdArgs.push_back("-fdollars-in-identifiers=1"); 549 else 550 CmdArgs.push_back("-fdollars-in-identifiers=0"); 551 } 552 553 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 554 // practical purposes. 555 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 556 options::OPT_fno_unit_at_a_time)) { 557 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 558 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 559 } 560 561 Args.AddLastArg(CmdArgs, options::OPT_dM); 562 Args.AddLastArg(CmdArgs, options::OPT_dD); 563 564 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 565 Args.AddAllArgValues(CmdArgs, options::OPT_mllvm); 566 567 if (Output.getType() == types::TY_Dependencies) { 568 // Handled with other dependency code. 569 } else if (Output.isPipe()) { 570 CmdArgs.push_back("-o"); 571 CmdArgs.push_back("-"); 572 } else if (Output.isFilename()) { 573 CmdArgs.push_back("-o"); 574 CmdArgs.push_back(Output.getFilename()); 575 } else { 576 assert(Output.isNothing() && "Invalid output."); 577 } 578 579 for (InputInfoList::const_iterator 580 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 581 const InputInfo &II = *it; 582 CmdArgs.push_back("-x"); 583 CmdArgs.push_back(types::getTypeName(II.getType())); 584 if (II.isPipe()) 585 CmdArgs.push_back("-"); 586 else if (II.isFilename()) 587 CmdArgs.push_back(II.getFilename()); 588 else 589 II.getInputArg().renderAsInput(Args, CmdArgs); 590 } 591 592 const char *Exec = 593 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang-cc").c_str()); 594 Dest.addCommand(new Command(Exec, CmdArgs)); 595 596 // Explicitly warn that these options are unsupported, even though 597 // we are allowing compilation to continue. 598 // FIXME: Use iterator. 599 for (ArgList::const_iterator 600 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 601 const Arg *A = *it; 602 if (A->getOption().matches(options::OPT_pg)) { 603 A->claim(); 604 D.Diag(clang::diag::warn_drv_clang_unsupported) 605 << A->getAsString(Args); 606 } 607 } 608 609 // Claim some arguments which clang supports automatically. 610 611 // -fpch-preprocess is used with gcc to add a special marker in the 612 // -output to include the PCH file. Clang's PTH solution is 613 // -completely transparent, so we do not need to deal with it at 614 // -all. 615 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 616 617 // Claim some arguments which clang doesn't support, but we don't 618 // care to warn the user about. 619 620 // FIXME: Use iterator. 621 for (ArgList::const_iterator 622 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 623 const Arg *A = *it; 624 if (A->getOption().matches(options::OPT_clang_ignored_f_Group) || 625 A->getOption().matches(options::OPT_clang_ignored_m_Group)) 626 A->claim(); 627 } 628} 629 630void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 631 Job &Dest, 632 const InputInfo &Output, 633 const InputInfoList &Inputs, 634 const ArgList &Args, 635 const char *LinkingOutput) const { 636 const Driver &D = getToolChain().getHost().getDriver(); 637 ArgStringList CmdArgs; 638 639 for (ArgList::const_iterator 640 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 641 Arg *A = *it; 642 if (A->getOption().hasForwardToGCC()) { 643 // It is unfortunate that we have to claim here, as this means 644 // we will basically never report anything interesting for 645 // platforms using a generic gcc, even if we are just using gcc 646 // to get to the assembler. 647 A->claim(); 648 A->render(Args, CmdArgs); 649 } 650 } 651 652 RenderExtraToolArgs(CmdArgs); 653 654 // If using a driver driver, force the arch. 655 const std::string &Arch = getToolChain().getArchName(); 656 if (getToolChain().getHost().useDriverDriver()) { 657 CmdArgs.push_back("-arch"); 658 659 // FIXME: Remove these special cases. 660 if (Arch == "powerpc") 661 CmdArgs.push_back("ppc"); 662 else if (Arch == "powerpc64") 663 CmdArgs.push_back("ppc64"); 664 else 665 CmdArgs.push_back(Args.MakeArgString(Arch.c_str())); 666 } 667 668 // Try to force gcc to match the tool chain we want, if we recognize 669 // the arch. 670 // 671 // FIXME: The triple class should directly provide the information we want 672 // here. 673 if (Arch == "i386" || Arch == "powerpc") 674 CmdArgs.push_back("-m32"); 675 else if (Arch == "x86_64" || Arch == "powerpc64") 676 CmdArgs.push_back("-m64"); 677 678 if (Output.isPipe()) { 679 CmdArgs.push_back("-o"); 680 CmdArgs.push_back("-"); 681 } else if (Output.isFilename()) { 682 CmdArgs.push_back("-o"); 683 CmdArgs.push_back(Output.getFilename()); 684 } else { 685 assert(Output.isNothing() && "Unexpected output"); 686 CmdArgs.push_back("-fsyntax-only"); 687 } 688 689 690 // Only pass -x if gcc will understand it; otherwise hope gcc 691 // understands the suffix correctly. The main use case this would go 692 // wrong in is for linker inputs if they happened to have an odd 693 // suffix; really the only way to get this to happen is a command 694 // like '-x foobar a.c' which will treat a.c like a linker input. 695 // 696 // FIXME: For the linker case specifically, can we safely convert 697 // inputs into '-Wl,' options? 698 for (InputInfoList::const_iterator 699 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 700 const InputInfo &II = *it; 701 702 // Don't try to pass LLVM inputs to a generic gcc. 703 if (II.getType() == types::TY_LLVMBC) 704 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 705 << getToolChain().getTripleString().c_str(); 706 707 if (types::canTypeBeUserSpecified(II.getType())) { 708 CmdArgs.push_back("-x"); 709 CmdArgs.push_back(types::getTypeName(II.getType())); 710 } 711 712 if (II.isPipe()) 713 CmdArgs.push_back("-"); 714 else if (II.isFilename()) 715 CmdArgs.push_back(II.getFilename()); 716 else 717 // Don't render as input, we need gcc to do the translations. 718 II.getInputArg().render(Args, CmdArgs); 719 } 720 721 const char *GCCName = 722 getToolChain().getHost().getDriver().CCCGenericGCCName.c_str(); 723 const char *Exec = 724 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName).c_str()); 725 Dest.addCommand(new Command(Exec, CmdArgs)); 726} 727 728void gcc::Preprocess::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 729 CmdArgs.push_back("-E"); 730} 731 732void gcc::Precompile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 733 // The type is good enough. 734} 735 736void gcc::Compile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 737 CmdArgs.push_back("-S"); 738} 739 740void gcc::Assemble::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 741 CmdArgs.push_back("-c"); 742} 743 744void gcc::Link::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 745 // The types are (hopefully) good enough. 746} 747 748const char *darwin::CC1::getCC1Name(types::ID Type) const { 749 switch (Type) { 750 default: 751 assert(0 && "Unexpected type for Darwin CC1 tool."); 752 case types::TY_Asm: 753 case types::TY_C: case types::TY_CHeader: 754 case types::TY_PP_C: case types::TY_PP_CHeader: 755 return "cc1"; 756 case types::TY_ObjC: case types::TY_ObjCHeader: 757 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 758 return "cc1obj"; 759 case types::TY_CXX: case types::TY_CXXHeader: 760 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 761 return "cc1plus"; 762 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 763 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 764 return "cc1objplus"; 765 } 766} 767 768const char *darwin::CC1::getBaseInputName(const ArgList &Args, 769 const InputInfoList &Inputs) { 770 llvm::sys::Path P(Inputs[0].getBaseInput()); 771 return Args.MakeArgString(P.getLast().c_str()); 772} 773 774const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 775 const InputInfoList &Inputs) { 776 const char *Str = getBaseInputName(Args, Inputs); 777 778 if (const char *End = strchr(Str, '.')) 779 return Args.MakeArgString(std::string(Str, End).c_str()); 780 781 return Str; 782} 783 784const char * 785darwin::CC1::getDependencyFileName(const ArgList &Args, 786 const InputInfoList &Inputs) { 787 // FIXME: Think about this more. 788 std::string Res; 789 790 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 791 std::string Str(OutputOpt->getValue(Args)); 792 793 Res = Str.substr(0, Str.rfind('.')); 794 } else 795 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 796 797 return Args.MakeArgString((Res + ".d").c_str()); 798} 799 800void darwin::CC1::AddCC1Args(const ArgList &Args, 801 ArgStringList &CmdArgs) const { 802 // Derived from cc1 spec. 803 804 // FIXME: -fapple-kext seems to disable this too. Investigate. 805 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 806 !Args.hasArg(options::OPT_mdynamic_no_pic)) 807 CmdArgs.push_back("-fPIC"); 808 809 // gcc has some code here to deal with when no -mmacosx-version-min 810 // and no -miphoneos-version-min is present, but this never happens 811 // due to tool chain specific argument translation. 812 813 // FIXME: Remove mthumb 814 // FIXME: Remove mno-thumb 815 // FIXME: Remove faltivec 816 // FIXME: Remove mno-fused-madd 817 // FIXME: Remove mlong-branch 818 // FIXME: Remove mlongcall 819 // FIXME: Remove mcpu=G4 820 // FIXME: Remove mcpu=G5 821 822 if (Args.hasArg(options::OPT_g_Flag) && 823 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 824 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 825} 826 827void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 828 const InputInfoList &Inputs, 829 const ArgStringList &OutputArgs) const { 830 const Driver &D = getToolChain().getHost().getDriver(); 831 832 // Derived from cc1_options spec. 833 if (Args.hasArg(options::OPT_fast) || 834 Args.hasArg(options::OPT_fastf) || 835 Args.hasArg(options::OPT_fastcp)) 836 CmdArgs.push_back("-O3"); 837 838 if (Arg *A = Args.getLastArg(options::OPT_pg)) 839 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 840 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 841 << A->getAsString(Args) << "-fomit-frame-pointer"; 842 843 AddCC1Args(Args, CmdArgs); 844 845 if (!Args.hasArg(options::OPT_Q)) 846 CmdArgs.push_back("-quiet"); 847 848 CmdArgs.push_back("-dumpbase"); 849 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 850 851 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 852 853 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 854 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 855 856 // FIXME: The goal is to use the user provided -o if that is our 857 // final output, otherwise to drive from the original input 858 // name. Find a clean way to go about this. 859 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 860 Args.hasArg(options::OPT_o)) { 861 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 862 CmdArgs.push_back("-auxbase-strip"); 863 CmdArgs.push_back(OutputOpt->getValue(Args)); 864 } else { 865 CmdArgs.push_back("-auxbase"); 866 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 867 } 868 869 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 870 871 Args.AddAllArgs(CmdArgs, options::OPT_O); 872 // FIXME: -Wall is getting some special treatment. Investigate. 873 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 874 Args.AddLastArg(CmdArgs, options::OPT_w); 875 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 876 options::OPT_trigraphs); 877 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 878 // Honor -std-default. 879 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 880 "-std=", /*Joined=*/true); 881 } 882 883 if (Args.hasArg(options::OPT_v)) 884 CmdArgs.push_back("-version"); 885 if (Args.hasArg(options::OPT_pg)) 886 CmdArgs.push_back("-p"); 887 Args.AddLastArg(CmdArgs, options::OPT_p); 888 889 // The driver treats -fsyntax-only specially. 890 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 891 892 Args.AddAllArgs(CmdArgs, options::OPT_undef); 893 if (Args.hasArg(options::OPT_Qn)) 894 CmdArgs.push_back("-fno-ident"); 895 896 // FIXME: This isn't correct. 897 //Args.AddLastArg(CmdArgs, options::OPT__help) 898 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 899 900 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 901 902 // FIXME: Still don't get what is happening here. Investigate. 903 Args.AddAllArgs(CmdArgs, options::OPT__param); 904 905 if (Args.hasArg(options::OPT_fmudflap) || 906 Args.hasArg(options::OPT_fmudflapth)) { 907 CmdArgs.push_back("-fno-builtin"); 908 CmdArgs.push_back("-fno-merge-constants"); 909 } 910 911 if (Args.hasArg(options::OPT_coverage)) { 912 CmdArgs.push_back("-fprofile-arcs"); 913 CmdArgs.push_back("-ftest-coverage"); 914 } 915 916 if (types::isCXX(Inputs[0].getType())) 917 CmdArgs.push_back("-D__private_extern__=extern"); 918} 919 920void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 921 const InputInfoList &Inputs, 922 const ArgStringList &OutputArgs) const { 923 // Derived from cpp_options 924 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 925 926 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 927 928 AddCC1Args(Args, CmdArgs); 929 930 // NOTE: The code below has some commonality with cpp_options, but 931 // in classic gcc style ends up sending things in different 932 // orders. This may be a good merge candidate once we drop pedantic 933 // compatibility. 934 935 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 936 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 937 options::OPT_trigraphs); 938 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 939 // Honor -std-default. 940 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 941 "-std=", /*Joined=*/true); 942 } 943 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 944 Args.AddLastArg(CmdArgs, options::OPT_w); 945 946 // The driver treats -fsyntax-only specially. 947 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 948 949 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 950 !Args.hasArg(options::OPT_fno_working_directory)) 951 CmdArgs.push_back("-fworking-directory"); 952 953 Args.AddAllArgs(CmdArgs, options::OPT_O); 954 Args.AddAllArgs(CmdArgs, options::OPT_undef); 955 if (Args.hasArg(options::OPT_save_temps)) 956 CmdArgs.push_back("-fpch-preprocess"); 957} 958 959void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 960 ArgStringList &CmdArgs, 961 const InputInfoList &Inputs) const 962{ 963 const Driver &D = getToolChain().getHost().getDriver(); 964 965 // Derived from cpp_unique_options. 966 Arg *A; 967 if ((A = Args.getLastArg(options::OPT_C)) || 968 (A = Args.getLastArg(options::OPT_CC))) { 969 if (!Args.hasArg(options::OPT_E)) 970 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 971 << A->getAsString(Args) << "-E"; 972 } 973 if (!Args.hasArg(options::OPT_Q)) 974 CmdArgs.push_back("-quiet"); 975 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 976 Args.AddLastArg(CmdArgs, options::OPT_v); 977 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 978 Args.AddLastArg(CmdArgs, options::OPT_P); 979 980 // FIXME: Handle %I properly. 981 if (getToolChain().getArchName() == "x86_64") { 982 CmdArgs.push_back("-imultilib"); 983 CmdArgs.push_back("x86_64"); 984 } 985 986 if (Args.hasArg(options::OPT_MD)) { 987 CmdArgs.push_back("-MD"); 988 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 989 } 990 991 if (Args.hasArg(options::OPT_MMD)) { 992 CmdArgs.push_back("-MMD"); 993 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 994 } 995 996 Args.AddLastArg(CmdArgs, options::OPT_M); 997 Args.AddLastArg(CmdArgs, options::OPT_MM); 998 Args.AddAllArgs(CmdArgs, options::OPT_MF); 999 Args.AddLastArg(CmdArgs, options::OPT_MG); 1000 Args.AddLastArg(CmdArgs, options::OPT_MP); 1001 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 1002 Args.AddAllArgs(CmdArgs, options::OPT_MT); 1003 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 1004 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 1005 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1006 CmdArgs.push_back("-MQ"); 1007 CmdArgs.push_back(OutputOpt->getValue(Args)); 1008 } 1009 } 1010 1011 Args.AddLastArg(CmdArgs, options::OPT_remap); 1012 if (Args.hasArg(options::OPT_g3)) 1013 CmdArgs.push_back("-dD"); 1014 Args.AddLastArg(CmdArgs, options::OPT_H); 1015 1016 AddCPPArgs(Args, CmdArgs); 1017 1018 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 1019 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 1020 1021 for (InputInfoList::const_iterator 1022 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1023 const InputInfo &II = *it; 1024 1025 if (II.isPipe()) 1026 CmdArgs.push_back("-"); 1027 else 1028 CmdArgs.push_back(II.getFilename()); 1029 } 1030 1031 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1032 options::OPT_Xpreprocessor); 1033 1034 if (Args.hasArg(options::OPT_fmudflap)) { 1035 CmdArgs.push_back("-D_MUDFLAP"); 1036 CmdArgs.push_back("-include"); 1037 CmdArgs.push_back("mf-runtime.h"); 1038 } 1039 1040 if (Args.hasArg(options::OPT_fmudflapth)) { 1041 CmdArgs.push_back("-D_MUDFLAP"); 1042 CmdArgs.push_back("-D_MUDFLAPTH"); 1043 CmdArgs.push_back("-include"); 1044 CmdArgs.push_back("mf-runtime.h"); 1045 } 1046} 1047 1048void darwin::CC1::AddCPPArgs(const ArgList &Args, 1049 ArgStringList &CmdArgs) const { 1050 // Derived from cpp spec. 1051 1052 if (Args.hasArg(options::OPT_static)) { 1053 // The gcc spec is broken here, it refers to dynamic but 1054 // that has been translated. Start by being bug compatible. 1055 1056 // if (!Args.hasArg(arglist.parser.dynamicOption)) 1057 CmdArgs.push_back("-D__STATIC__"); 1058 } else 1059 CmdArgs.push_back("-D__DYNAMIC__"); 1060 1061 if (Args.hasArg(options::OPT_pthread)) 1062 CmdArgs.push_back("-D_REENTRANT"); 1063} 1064 1065void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 1066 Job &Dest, const InputInfo &Output, 1067 const InputInfoList &Inputs, 1068 const ArgList &Args, 1069 const char *LinkingOutput) const { 1070 ArgStringList CmdArgs; 1071 1072 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1073 1074 CmdArgs.push_back("-E"); 1075 1076 if (Args.hasArg(options::OPT_traditional) || 1077 Args.hasArg(options::OPT_ftraditional) || 1078 Args.hasArg(options::OPT_traditional_cpp)) 1079 CmdArgs.push_back("-traditional-cpp"); 1080 1081 ArgStringList OutputArgs; 1082 if (Output.isFilename()) { 1083 OutputArgs.push_back("-o"); 1084 OutputArgs.push_back(Output.getFilename()); 1085 } else { 1086 assert(Output.isPipe() && "Unexpected CC1 output."); 1087 } 1088 1089 if (Args.hasArg(options::OPT_E)) { 1090 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1091 } else { 1092 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1093 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1094 } 1095 1096 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1097 1098 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1099 const char *Exec = 1100 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str()); 1101 Dest.addCommand(new Command(Exec, CmdArgs)); 1102} 1103 1104void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 1105 Job &Dest, const InputInfo &Output, 1106 const InputInfoList &Inputs, 1107 const ArgList &Args, 1108 const char *LinkingOutput) const { 1109 const Driver &D = getToolChain().getHost().getDriver(); 1110 ArgStringList CmdArgs; 1111 1112 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1113 1114 types::ID InputType = Inputs[0].getType(); 1115 const Arg *A; 1116 if ((A = Args.getLastArg(options::OPT_traditional)) || 1117 (A = Args.getLastArg(options::OPT_ftraditional))) 1118 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1119 << A->getAsString(Args) << "-E"; 1120 1121 if (Output.getType() == types::TY_LLVMAsm) 1122 CmdArgs.push_back("-emit-llvm"); 1123 else if (Output.getType() == types::TY_LLVMBC) 1124 CmdArgs.push_back("-emit-llvm-bc"); 1125 1126 ArgStringList OutputArgs; 1127 if (Output.getType() != types::TY_PCH) { 1128 OutputArgs.push_back("-o"); 1129 if (Output.isPipe()) 1130 OutputArgs.push_back("-"); 1131 else if (Output.isNothing()) 1132 OutputArgs.push_back("/dev/null"); 1133 else 1134 OutputArgs.push_back(Output.getFilename()); 1135 } 1136 1137 // There is no need for this level of compatibility, but it makes 1138 // diffing easier. 1139 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 1140 Args.hasArg(options::OPT_S)); 1141 1142 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 1143 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1144 if (OutputArgsEarly) { 1145 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1146 } else { 1147 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1148 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1149 } 1150 } else { 1151 CmdArgs.push_back("-fpreprocessed"); 1152 1153 // FIXME: There is a spec command to remove 1154 // -fpredictive-compilation args here. Investigate. 1155 1156 for (InputInfoList::const_iterator 1157 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1158 const InputInfo &II = *it; 1159 1160 if (II.isPipe()) 1161 CmdArgs.push_back("-"); 1162 else 1163 CmdArgs.push_back(II.getFilename()); 1164 } 1165 1166 if (OutputArgsEarly) { 1167 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1168 } else { 1169 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1170 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1171 } 1172 } 1173 1174 if (Output.getType() == types::TY_PCH) { 1175 assert(Output.isFilename() && "Invalid PCH output."); 1176 1177 CmdArgs.push_back("-o"); 1178 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 1179 // to be a good reason. 1180 CmdArgs.push_back("/dev/null"); 1181 1182 CmdArgs.push_back("--output-pch="); 1183 CmdArgs.push_back(Output.getFilename()); 1184 } 1185 1186 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1187 const char *Exec = 1188 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str()); 1189 Dest.addCommand(new Command(Exec, CmdArgs)); 1190} 1191 1192void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1193 Job &Dest, const InputInfo &Output, 1194 const InputInfoList &Inputs, 1195 const ArgList &Args, 1196 const char *LinkingOutput) const { 1197 ArgStringList CmdArgs; 1198 1199 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1200 const InputInfo &Input = Inputs[0]; 1201 1202 // Bit of a hack, this is only used for original inputs. 1203 // 1204 // FIXME: This is broken for preprocessed .s inputs. 1205 if (Input.isFilename() && 1206 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 1207 if (Args.hasArg(options::OPT_gstabs)) 1208 CmdArgs.push_back("--gstabs"); 1209 else if (Args.hasArg(options::OPT_g_Group)) 1210 CmdArgs.push_back("--gdwarf2"); 1211 } 1212 1213 // Derived from asm spec. 1214 CmdArgs.push_back("-arch"); 1215 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName().c_str())); 1216 1217 CmdArgs.push_back("-force_cpusubtype_ALL"); 1218 if ((Args.hasArg(options::OPT_mkernel) || 1219 Args.hasArg(options::OPT_static) || 1220 Args.hasArg(options::OPT_fapple_kext)) && 1221 !Args.hasArg(options::OPT_dynamic)) 1222 CmdArgs.push_back("-static"); 1223 1224 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1225 options::OPT_Xassembler); 1226 1227 assert(Output.isFilename() && "Unexpected lipo output."); 1228 CmdArgs.push_back("-o"); 1229 CmdArgs.push_back(Output.getFilename()); 1230 1231 if (Input.isPipe()) { 1232 CmdArgs.push_back("-"); 1233 } else { 1234 assert(Input.isFilename() && "Invalid input."); 1235 CmdArgs.push_back(Input.getFilename()); 1236 } 1237 1238 // asm_final spec is empty. 1239 1240 const char *Exec = 1241 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1242 Dest.addCommand(new Command(Exec, CmdArgs)); 1243} 1244 1245/// Helper routine for seeing if we should use dsymutil; this is a 1246/// gcc compatible hack, we should remove it and use the input 1247/// type information. 1248static bool isSourceSuffix(const char *Str) { 1249 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm', 1250 // 'mm'. 1251 switch (strlen(Str)) { 1252 default: 1253 return false; 1254 case 1: 1255 return (memcmp(Str, "C", 1) == 0 || 1256 memcmp(Str, "c", 1) == 0 || 1257 memcmp(Str, "m", 1) == 0); 1258 case 2: 1259 return (memcmp(Str, "cc", 2) == 0 || 1260 memcmp(Str, "cp", 2) == 0 || 1261 memcmp(Str, "mm", 2) == 0); 1262 case 3: 1263 return (memcmp(Str, "CPP", 3) == 0 || 1264 memcmp(Str, "c++", 3) == 0 || 1265 memcmp(Str, "cpp", 3) == 0 || 1266 memcmp(Str, "cxx", 3) == 0); 1267 } 1268} 1269 1270static bool isMacosxVersionLT(unsigned (&A)[3], unsigned (&B)[3]) { 1271 for (unsigned i=0; i < 3; ++i) { 1272 if (A[i] > B[i]) return false; 1273 if (A[i] < B[i]) return true; 1274 } 1275 return false; 1276} 1277 1278static bool isMacosxVersionLT(unsigned (&A)[3], 1279 unsigned V0, unsigned V1=0, unsigned V2=0) { 1280 unsigned B[3] = { V0, V1, V2 }; 1281 return isMacosxVersionLT(A, B); 1282} 1283 1284const toolchains::Darwin_X86 &darwin::Link::getDarwinToolChain() const { 1285 return reinterpret_cast<const toolchains::Darwin_X86&>(getToolChain()); 1286} 1287 1288void darwin::Link::AddDarwinArch(const ArgList &Args, 1289 ArgStringList &CmdArgs) const { 1290 // Derived from darwin_arch spec. 1291 CmdArgs.push_back("-arch"); 1292 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName().c_str())); 1293} 1294 1295void darwin::Link::AddDarwinSubArch(const ArgList &Args, 1296 ArgStringList &CmdArgs) const { 1297 // Derived from darwin_subarch spec, not sure what the distinction 1298 // exists for but at least for this chain it is the same. 1299 AddDarwinArch(Args, CmdArgs); 1300} 1301 1302void darwin::Link::AddLinkArgs(const ArgList &Args, 1303 ArgStringList &CmdArgs) const { 1304 const Driver &D = getToolChain().getHost().getDriver(); 1305 1306 // Derived from the "link" spec. 1307 Args.AddAllArgs(CmdArgs, options::OPT_static); 1308 if (!Args.hasArg(options::OPT_static)) 1309 CmdArgs.push_back("-dynamic"); 1310 if (Args.hasArg(options::OPT_fgnu_runtime)) { 1311 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 1312 // here. How do we wish to handle such things? 1313 } 1314 1315 if (!Args.hasArg(options::OPT_dynamiclib)) { 1316 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1317 AddDarwinArch(Args, CmdArgs); 1318 CmdArgs.push_back("-force_cpusubtype_ALL"); 1319 } else 1320 AddDarwinSubArch(Args, CmdArgs); 1321 1322 Args.AddLastArg(CmdArgs, options::OPT_bundle); 1323 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 1324 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 1325 1326 Arg *A; 1327 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 1328 (A = Args.getLastArg(options::OPT_current__version)) || 1329 (A = Args.getLastArg(options::OPT_install__name))) 1330 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1331 << A->getAsString(Args) << "-dynamiclib"; 1332 1333 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 1334 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 1335 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 1336 } else { 1337 CmdArgs.push_back("-dylib"); 1338 1339 Arg *A; 1340 if ((A = Args.getLastArg(options::OPT_bundle)) || 1341 (A = Args.getLastArg(options::OPT_bundle__loader)) || 1342 (A = Args.getLastArg(options::OPT_client__name)) || 1343 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 1344 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 1345 (A = Args.getLastArg(options::OPT_private__bundle))) 1346 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1347 << A->getAsString(Args) << "-dynamiclib"; 1348 1349 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 1350 "-dylib_compatibility_version"); 1351 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 1352 "-dylib_current_version"); 1353 1354 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1355 AddDarwinArch(Args, CmdArgs); 1356 // NOTE: We don't add -force_cpusubtype_ALL on this path. Ok. 1357 } else 1358 AddDarwinSubArch(Args, CmdArgs); 1359 1360 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 1361 "-dylib_install_name"); 1362 } 1363 1364 Args.AddLastArg(CmdArgs, options::OPT_all__load); 1365 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 1366 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 1367 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 1368 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 1369 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 1370 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 1371 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 1372 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 1373 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 1374 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 1375 Args.AddAllArgs(CmdArgs, options::OPT_init); 1376 1377 if (!Args.hasArg(options::OPT_mmacosx_version_min_EQ)) { 1378 if (!Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 1379 // FIXME: I don't understand what is going on here. This is 1380 // supposed to come from darwin_ld_minversion, but gcc doesn't 1381 // seem to be following that; it must be getting overridden 1382 // somewhere. 1383 CmdArgs.push_back("-macosx_version_min"); 1384 CmdArgs.push_back(getDarwinToolChain().getMacosxVersionStr()); 1385 } 1386 } else { 1387 // Adding all arguments doesn't make sense here but this is what 1388 // gcc does. 1389 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 1390 "-macosx_version_min"); 1391 } 1392 1393 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 1394 "-iphoneos_version_min"); 1395 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 1396 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 1397 Args.AddLastArg(CmdArgs, options::OPT_single__module); 1398 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 1399 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 1400 1401 if (Args.hasArg(options::OPT_fpie)) 1402 CmdArgs.push_back("-pie"); 1403 1404 Args.AddLastArg(CmdArgs, options::OPT_prebind); 1405 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 1406 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 1407 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 1408 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 1409 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 1410 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 1411 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 1412 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 1413 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 1414 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 1415 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 1416 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 1417 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 1418 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 1419 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 1420 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 1421 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 1422 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 1423 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 1424 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 1425 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 1426 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 1427 1428 if (!Args.hasArg(options::OPT_weak__reference__mismatches)) { 1429 CmdArgs.push_back("-weak_reference_mismatches"); 1430 CmdArgs.push_back("non-weak"); 1431 } 1432 1433 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 1434 Args.AddAllArgs(CmdArgs, options::OPT_y); 1435 Args.AddLastArg(CmdArgs, options::OPT_w); 1436 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 1437 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 1438 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 1439 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 1440 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 1441 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 1442 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 1443 Args.AddLastArg(CmdArgs, options::OPT_whyload); 1444 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 1445 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 1446 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 1447 Args.AddLastArg(CmdArgs, options::OPT_Mach); 1448} 1449 1450void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 1451 Job &Dest, const InputInfo &Output, 1452 const InputInfoList &Inputs, 1453 const ArgList &Args, 1454 const char *LinkingOutput) const { 1455 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 1456 // The logic here is derived from gcc's behavior; most of which 1457 // comes from specs (starting with link_command). Consult gcc for 1458 // more information. 1459 1460 // FIXME: The spec references -fdump= which seems to have 1461 // disappeared? 1462 1463 ArgStringList CmdArgs; 1464 1465 // I'm not sure why this particular decomposition exists in gcc, but 1466 // we follow suite for ease of comparison. 1467 AddLinkArgs(Args, CmdArgs); 1468 1469 // FIXME: gcc has %{x} in here. How could this ever happen? Cruft? 1470 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 1471 Args.AddAllArgs(CmdArgs, options::OPT_s); 1472 Args.AddAllArgs(CmdArgs, options::OPT_t); 1473 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 1474 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 1475 Args.AddAllArgs(CmdArgs, options::OPT_A); 1476 Args.AddLastArg(CmdArgs, options::OPT_e); 1477 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 1478 Args.AddAllArgs(CmdArgs, options::OPT_r); 1479 1480 // FIXME: This is just being pedantically bug compatible, gcc 1481 // doesn't *mean* to forward this, it just does (yay for pattern 1482 // matching). It doesn't work, of course. 1483 Args.AddAllArgs(CmdArgs, options::OPT_object); 1484 1485 CmdArgs.push_back("-o"); 1486 CmdArgs.push_back(Output.getFilename()); 1487 1488 unsigned MacosxVersion[3]; 1489 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) { 1490 bool HadExtra; 1491 if (!Driver::GetReleaseVersion(A->getValue(Args), MacosxVersion[0], 1492 MacosxVersion[1], MacosxVersion[2], 1493 HadExtra) || 1494 HadExtra) { 1495 const Driver &D = getToolChain().getHost().getDriver(); 1496 D.Diag(clang::diag::err_drv_invalid_version_number) 1497 << A->getAsString(Args); 1498 } 1499 } else { 1500 getDarwinToolChain().getMacosxVersion(MacosxVersion); 1501 } 1502 1503 if (!Args.hasArg(options::OPT_A) && 1504 !Args.hasArg(options::OPT_nostdlib) && 1505 !Args.hasArg(options::OPT_nostartfiles)) { 1506 // Derived from startfile spec. 1507 if (Args.hasArg(options::OPT_dynamiclib)) { 1508 // Derived from darwin_dylib1 spec. 1509 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1510 CmdArgs.push_back("-ldylib1.o"); 1511 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1512 CmdArgs.push_back("-ldylib1.10.5.o"); 1513 } else { 1514 if (Args.hasArg(options::OPT_bundle)) { 1515 if (!Args.hasArg(options::OPT_static)) { 1516 // Derived from darwin_bundle1 spec. 1517 if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1518 CmdArgs.push_back("-lbundle1.o"); 1519 } 1520 } else { 1521 if (Args.hasArg(options::OPT_pg)) { 1522 if (Args.hasArg(options::OPT_static) || 1523 Args.hasArg(options::OPT_object) || 1524 Args.hasArg(options::OPT_preload)) { 1525 CmdArgs.push_back("-lgcrt0.o"); 1526 } else { 1527 CmdArgs.push_back("-lgcrt1.o"); 1528 1529 // darwin_crt2 spec is empty. 1530 } 1531 } else { 1532 if (Args.hasArg(options::OPT_static) || 1533 Args.hasArg(options::OPT_object) || 1534 Args.hasArg(options::OPT_preload)) { 1535 CmdArgs.push_back("-lcrt0.o"); 1536 } else { 1537 // Derived from darwin_crt1 spec. 1538 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1539 CmdArgs.push_back("-lcrt1.o"); 1540 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1541 CmdArgs.push_back("-lcrt1.10.5.o"); 1542 else 1543 CmdArgs.push_back("-lcrt1.10.6.o"); 1544 1545 // darwin_crt2 spec is empty. 1546 } 1547 } 1548 } 1549 } 1550 1551 if (Args.hasArg(options::OPT_shared_libgcc) && 1552 !Args.hasArg(options::OPT_miphoneos_version_min_EQ) && 1553 isMacosxVersionLT(MacosxVersion, 10, 5)) { 1554 const char *Str = getToolChain().GetFilePath(C, "crt3.o").c_str(); 1555 CmdArgs.push_back(Args.MakeArgString(Str)); 1556 } 1557 } 1558 1559 Args.AddAllArgs(CmdArgs, options::OPT_L); 1560 1561 if (Args.hasArg(options::OPT_fopenmp)) 1562 // This is more complicated in gcc... 1563 CmdArgs.push_back("-lgomp"); 1564 1565 // FIXME: Derive these correctly. 1566 const char *TCDir = getDarwinToolChain().getToolChainDir().c_str(); 1567 if (getToolChain().getArchName() == "x86_64") { 1568 CmdArgs.push_back(MakeFormattedString(Args, 1569 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir))); 1570 // Intentionally duplicated for (temporary) gcc bug compatibility. 1571 CmdArgs.push_back(MakeFormattedString(Args, 1572 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir))); 1573 } 1574 CmdArgs.push_back(MakeFormattedString(Args, 1575 llvm::format("-L/usr/lib/%s", TCDir))); 1576 CmdArgs.push_back(MakeFormattedString(Args, 1577 llvm::format("-L/usr/lib/gcc/%s", TCDir))); 1578 // Intentionally duplicated for (temporary) gcc bug compatibility. 1579 CmdArgs.push_back(MakeFormattedString(Args, 1580 llvm::format("-L/usr/lib/gcc/%s", TCDir))); 1581 CmdArgs.push_back(MakeFormattedString(Args, 1582 llvm::format("-L/usr/lib/gcc/%s/../../../%s", TCDir, TCDir))); 1583 CmdArgs.push_back(MakeFormattedString(Args, 1584 llvm::format("-L/usr/lib/gcc/%s/../../..", TCDir))); 1585 1586 for (InputInfoList::const_iterator 1587 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1588 const InputInfo &II = *it; 1589 if (II.isFilename()) 1590 CmdArgs.push_back(II.getFilename()); 1591 else 1592 II.getInputArg().renderAsInput(Args, CmdArgs); 1593 } 1594 1595 if (LinkingOutput) { 1596 CmdArgs.push_back("-arch_multiple"); 1597 CmdArgs.push_back("-final_output"); 1598 CmdArgs.push_back(LinkingOutput); 1599 } 1600 1601 if (Args.hasArg(options::OPT_fprofile_arcs) || 1602 Args.hasArg(options::OPT_fprofile_generate) || 1603 Args.hasArg(options::OPT_fcreate_profile) || 1604 Args.hasArg(options::OPT_coverage)) 1605 CmdArgs.push_back("-lgcov"); 1606 1607 if (Args.hasArg(options::OPT_fnested_functions)) 1608 CmdArgs.push_back("-allow_stack_execute"); 1609 1610 if (!Args.hasArg(options::OPT_nostdlib) && 1611 !Args.hasArg(options::OPT_nodefaultlibs)) { 1612 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 1613 // before -lm, for example. 1614 if (getToolChain().getHost().getDriver().CCCIsCXX) 1615 CmdArgs.push_back("-lstdc++"); 1616 1617 // link_ssp spec is empty. 1618 1619 // Derived from libgcc and lib specs but refactored. 1620 if (Args.hasArg(options::OPT_static)) { 1621 CmdArgs.push_back("-lgcc_static"); 1622 } else { 1623 if (Args.hasArg(options::OPT_static_libgcc)) { 1624 CmdArgs.push_back("-lgcc_eh"); 1625 } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 1626 // Derived from darwin_iphoneos_libgcc spec. 1627 CmdArgs.push_back("-lgcc_s.10.5"); 1628 } else if (Args.hasArg(options::OPT_shared_libgcc) || 1629 Args.hasArg(options::OPT_fexceptions) || 1630 Args.hasArg(options::OPT_fgnu_runtime)) { 1631 // FIXME: This is probably broken on 10.3? 1632 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1633 CmdArgs.push_back("-lgcc_s.10.4"); 1634 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1635 CmdArgs.push_back("-lgcc_s.10.5"); 1636 } else { 1637 if (isMacosxVersionLT(MacosxVersion, 10, 3, 9)) 1638 ; // Do nothing. 1639 else if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1640 CmdArgs.push_back("-lgcc_s.10.4"); 1641 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1642 CmdArgs.push_back("-lgcc_s.10.5"); 1643 } 1644 1645 if (isMacosxVersionLT(MacosxVersion, 10, 6)) { 1646 CmdArgs.push_back("-lgcc"); 1647 CmdArgs.push_back("-lSystem"); 1648 } else { 1649 CmdArgs.push_back("-lSystem"); 1650 CmdArgs.push_back("-lgcc"); 1651 } 1652 } 1653 } 1654 1655 if (!Args.hasArg(options::OPT_A) && 1656 !Args.hasArg(options::OPT_nostdlib) && 1657 !Args.hasArg(options::OPT_nostartfiles)) { 1658 // endfile_spec is empty. 1659 } 1660 1661 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1662 Args.AddAllArgs(CmdArgs, options::OPT_F); 1663 1664 const char *Exec = 1665 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 1666 Dest.addCommand(new Command(Exec, CmdArgs)); 1667 1668 // Find the first non-empty base input (we want to ignore linker 1669 // inputs). 1670 const char *BaseInput = ""; 1671 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1672 if (Inputs[i].getBaseInput()[0] != '\0') { 1673 BaseInput = Inputs[i].getBaseInput(); 1674 break; 1675 } 1676 } 1677 1678 // Run dsymutil if we are making an executable in a single step. 1679 // 1680 // FIXME: Currently we don't want to do this when we are part of a 1681 // universal build step, as this would end up creating stray temp 1682 // files. 1683 if (!LinkingOutput && 1684 Args.getLastArg(options::OPT_g_Group) && 1685 !Args.getLastArg(options::OPT_gstabs) && 1686 !Args.getLastArg(options::OPT_g0)) { 1687 // FIXME: This is gross, but matches gcc. The test only considers 1688 // the suffix (not the -x type), and then only of the first 1689 // source input. Awesome. 1690 const char *Suffix = strrchr(BaseInput, '.'); 1691 if (Suffix && isSourceSuffix(Suffix + 1)) { 1692 const char *Exec = 1693 Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil").c_str()); 1694 ArgStringList CmdArgs; 1695 CmdArgs.push_back(Output.getFilename()); 1696 C.getJobs().addCommand(new Command(Exec, CmdArgs)); 1697 } 1698 } 1699} 1700 1701void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 1702 Job &Dest, const InputInfo &Output, 1703 const InputInfoList &Inputs, 1704 const ArgList &Args, 1705 const char *LinkingOutput) const { 1706 ArgStringList CmdArgs; 1707 1708 CmdArgs.push_back("-create"); 1709 assert(Output.isFilename() && "Unexpected lipo output."); 1710 1711 CmdArgs.push_back("-output"); 1712 CmdArgs.push_back(Output.getFilename()); 1713 1714 for (InputInfoList::const_iterator 1715 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1716 const InputInfo &II = *it; 1717 assert(II.isFilename() && "Unexpected lipo input."); 1718 CmdArgs.push_back(II.getFilename()); 1719 } 1720 const char *Exec = 1721 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo").c_str()); 1722 Dest.addCommand(new Command(Exec, CmdArgs)); 1723} 1724 1725 1726void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1727 Job &Dest, const InputInfo &Output, 1728 const InputInfoList &Inputs, 1729 const ArgList &Args, 1730 const char *LinkingOutput) const 1731{ 1732 ArgStringList CmdArgs; 1733 1734 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 1735 // instruct as in the base system to assemble 32-bit code. 1736 if (getToolChain().getArchName() == "i386") 1737 CmdArgs.push_back("--32"); 1738 1739 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1740 options::OPT_Xassembler); 1741 1742 CmdArgs.push_back("-o"); 1743 if (Output.isPipe()) 1744 CmdArgs.push_back("-"); 1745 else 1746 CmdArgs.push_back(Output.getFilename()); 1747 1748 for (InputInfoList::const_iterator 1749 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1750 const InputInfo &II = *it; 1751 if (II.isPipe()) 1752 CmdArgs.push_back("-"); 1753 else 1754 CmdArgs.push_back(II.getFilename()); 1755 } 1756 1757 const char *Exec = 1758 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1759 Dest.addCommand(new Command(Exec, CmdArgs)); 1760} 1761 1762void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 1763 Job &Dest, const InputInfo &Output, 1764 const InputInfoList &Inputs, 1765 const ArgList &Args, 1766 const char *LinkingOutput) const { 1767 const Driver &D = getToolChain().getHost().getDriver(); 1768 ArgStringList CmdArgs; 1769 1770 if (Args.hasArg(options::OPT_static)) { 1771 CmdArgs.push_back("-Bstatic"); 1772 } else { 1773 CmdArgs.push_back("--eh-frame-hdr"); 1774 if (Args.hasArg(options::OPT_shared)) { 1775 CmdArgs.push_back("-Bshareable"); 1776 } else { 1777 CmdArgs.push_back("-dynamic-linker"); 1778 CmdArgs.push_back("/libexec/ld-elf.so.1"); 1779 } 1780 } 1781 1782 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 1783 // instruct ld in the base system to link 32-bit code. 1784 if (getToolChain().getArchName() == "i386") { 1785 CmdArgs.push_back("-m"); 1786 CmdArgs.push_back("elf_i386_fbsd"); 1787 } 1788 1789 if (Output.isPipe()) { 1790 CmdArgs.push_back("-o"); 1791 CmdArgs.push_back("-"); 1792 } else if (Output.isFilename()) { 1793 CmdArgs.push_back("-o"); 1794 CmdArgs.push_back(Output.getFilename()); 1795 } else { 1796 assert(Output.isNothing() && "Invalid output."); 1797 } 1798 1799 if (!Args.hasArg(options::OPT_nostdlib) && 1800 !Args.hasArg(options::OPT_nostartfiles)) { 1801 if (!Args.hasArg(options::OPT_shared)) { 1802 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o").c_str())); 1803 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1804 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o").c_str())); 1805 } else { 1806 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1807 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o").c_str())); 1808 } 1809 } 1810 1811 Args.AddAllArgs(CmdArgs, options::OPT_L); 1812 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1813 Args.AddAllArgs(CmdArgs, options::OPT_e); 1814 1815 for (InputInfoList::const_iterator 1816 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1817 const InputInfo &II = *it; 1818 1819 // Don't try to pass LLVM inputs to a generic gcc. 1820 if (II.getType() == types::TY_LLVMBC) 1821 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1822 << getToolChain().getTripleString().c_str(); 1823 1824 if (II.isPipe()) 1825 CmdArgs.push_back("-"); 1826 else if (II.isFilename()) 1827 CmdArgs.push_back(II.getFilename()); 1828 else 1829 II.getInputArg().renderAsInput(Args, CmdArgs); 1830 } 1831 1832 if (!Args.hasArg(options::OPT_nostdlib) && 1833 !Args.hasArg(options::OPT_nodefaultlibs)) { 1834 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 1835 // the default system libraries. Just mimic this for now. 1836 CmdArgs.push_back("-lgcc"); 1837 if (Args.hasArg(options::OPT_static)) { 1838 CmdArgs.push_back("-lgcc_eh"); 1839 } else { 1840 CmdArgs.push_back("--as-needed"); 1841 CmdArgs.push_back("-lgcc_s"); 1842 CmdArgs.push_back("--no-as-needed"); 1843 } 1844 1845 if (Args.hasArg(options::OPT_pthread)) 1846 CmdArgs.push_back("-lpthread"); 1847 CmdArgs.push_back("-lc"); 1848 1849 CmdArgs.push_back("-lgcc"); 1850 if (Args.hasArg(options::OPT_static)) { 1851 CmdArgs.push_back("-lgcc_eh"); 1852 } else { 1853 CmdArgs.push_back("--as-needed"); 1854 CmdArgs.push_back("-lgcc_s"); 1855 CmdArgs.push_back("--no-as-needed"); 1856 } 1857 } 1858 1859 if (!Args.hasArg(options::OPT_nostdlib) && 1860 !Args.hasArg(options::OPT_nostartfiles)) { 1861 if (!Args.hasArg(options::OPT_shared)) 1862 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o").c_str())); 1863 else 1864 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o").c_str())); 1865 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o").c_str())); 1866 } 1867 1868 const char *Exec = 1869 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 1870 Dest.addCommand(new Command(Exec, CmdArgs)); 1871} 1872 1873/// DragonFly Tools 1874 1875// For now, DragonFly Assemble does just about the same as for 1876// FreeBSD, but this may change soon. 1877void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1878 Job &Dest, const InputInfo &Output, 1879 const InputInfoList &Inputs, 1880 const ArgList &Args, 1881 const char *LinkingOutput) const { 1882 ArgStringList CmdArgs; 1883 1884 // When building 32-bit code on DragonFly/pc64, we have to explicitly 1885 // instruct as in the base system to assemble 32-bit code. 1886 if (getToolChain().getArchName() == "i386") 1887 CmdArgs.push_back("--32"); 1888 1889 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1890 options::OPT_Xassembler); 1891 1892 CmdArgs.push_back("-o"); 1893 if (Output.isPipe()) 1894 CmdArgs.push_back("-"); 1895 else 1896 CmdArgs.push_back(Output.getFilename()); 1897 1898 for (InputInfoList::const_iterator 1899 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1900 const InputInfo &II = *it; 1901 if (II.isPipe()) 1902 CmdArgs.push_back("-"); 1903 else 1904 CmdArgs.push_back(II.getFilename()); 1905 } 1906 1907 const char *Exec = 1908 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1909 Dest.addCommand(new Command(Exec, CmdArgs)); 1910} 1911 1912void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 1913 Job &Dest, const InputInfo &Output, 1914 const InputInfoList &Inputs, 1915 const ArgList &Args, 1916 const char *LinkingOutput) const { 1917 const Driver &D = getToolChain().getHost().getDriver(); 1918 ArgStringList CmdArgs; 1919 1920 if (Args.hasArg(options::OPT_static)) { 1921 CmdArgs.push_back("-Bstatic"); 1922 } else { 1923 if (Args.hasArg(options::OPT_shared)) 1924 CmdArgs.push_back("-Bshareable"); 1925 else { 1926 CmdArgs.push_back("-dynamic-linker"); 1927 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 1928 } 1929 } 1930 1931 // When building 32-bit code on DragonFly/pc64, we have to explicitly 1932 // instruct ld in the base system to link 32-bit code. 1933 if (getToolChain().getArchName() == "i386") { 1934 CmdArgs.push_back("-m"); 1935 CmdArgs.push_back("elf_i386"); 1936 } 1937 1938 if (Output.isPipe()) { 1939 CmdArgs.push_back("-o"); 1940 CmdArgs.push_back("-"); 1941 } else if (Output.isFilename()) { 1942 CmdArgs.push_back("-o"); 1943 CmdArgs.push_back(Output.getFilename()); 1944 } else { 1945 assert(Output.isNothing() && "Invalid output."); 1946 } 1947 1948 if (!Args.hasArg(options::OPT_nostdlib) && 1949 !Args.hasArg(options::OPT_nostartfiles)) { 1950 if (!Args.hasArg(options::OPT_shared)) { 1951 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o").c_str())); 1952 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1953 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o").c_str())); 1954 } else { 1955 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1956 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o").c_str())); 1957 } 1958 } 1959 1960 Args.AddAllArgs(CmdArgs, options::OPT_L); 1961 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1962 Args.AddAllArgs(CmdArgs, options::OPT_e); 1963 1964 for (InputInfoList::const_iterator 1965 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1966 const InputInfo &II = *it; 1967 1968 // Don't try to pass LLVM inputs to a generic gcc. 1969 if (II.getType() == types::TY_LLVMBC) 1970 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1971 << getToolChain().getTripleString().c_str(); 1972 1973 if (II.isPipe()) 1974 CmdArgs.push_back("-"); 1975 else if (II.isFilename()) 1976 CmdArgs.push_back(II.getFilename()); 1977 else 1978 II.getInputArg().renderAsInput(Args, CmdArgs); 1979 } 1980 1981 if (!Args.hasArg(options::OPT_nostdlib) && 1982 !Args.hasArg(options::OPT_nodefaultlibs)) { 1983 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 1984 // rpaths 1985 CmdArgs.push_back("-L/usr/lib/gcc41"); 1986 1987 if (!Args.hasArg(options::OPT_static)) { 1988 CmdArgs.push_back("-rpath"); 1989 CmdArgs.push_back("/usr/lib/gcc41"); 1990 1991 CmdArgs.push_back("-rpath-link"); 1992 CmdArgs.push_back("/usr/lib/gcc41"); 1993 1994 CmdArgs.push_back("-rpath"); 1995 CmdArgs.push_back("/usr/lib"); 1996 1997 CmdArgs.push_back("-rpath-link"); 1998 CmdArgs.push_back("/usr/lib"); 1999 } 2000 2001 if (Args.hasArg(options::OPT_shared)) { 2002 CmdArgs.push_back("-lgcc_pic"); 2003 } else { 2004 CmdArgs.push_back("-lgcc"); 2005 } 2006 2007 2008 if (Args.hasArg(options::OPT_pthread)) 2009 CmdArgs.push_back("-lthread_xu"); 2010 2011 if (!Args.hasArg(options::OPT_nolibc)) { 2012 CmdArgs.push_back("-lc"); 2013 } 2014 2015 if (Args.hasArg(options::OPT_shared)) { 2016 CmdArgs.push_back("-lgcc_pic"); 2017 } else { 2018 CmdArgs.push_back("-lgcc"); 2019 } 2020 } 2021 2022 if (!Args.hasArg(options::OPT_nostdlib) && 2023 !Args.hasArg(options::OPT_nostartfiles)) { 2024 if (!Args.hasArg(options::OPT_shared)) 2025 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o").c_str())); 2026 else 2027 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o").c_str())); 2028 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o").c_str())); 2029 } 2030 2031 const char *Exec = 2032 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 2033 Dest.addCommand(new Command(Exec, CmdArgs)); 2034} 2035