Tools.cpp revision 193576
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("--no-implicit-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 // -fsigned-char/-funsigned-char default varies depending on platform; only 509 // pass if specified. 510 if (Arg *A = Args.getLastArg(options::OPT_fsigned_char, 511 options::OPT_funsigned_char)) { 512 if (A->getOption().matches(options::OPT_fsigned_char)) 513 CmdArgs.push_back("-fsigned-char"); 514 else 515 CmdArgs.push_back("-fsigned-char=0"); 516 } 517 518 // -fno-pascal-strings is default, only pass non-default. If the 519 // -tool chain happened to translate to -mpascal-strings, we want to 520 // -back translate here. 521 // 522 // FIXME: This is gross; that translation should be pulled from the 523 // tool chain. 524 if (Args.hasFlag(options::OPT_fpascal_strings, 525 options::OPT_fno_pascal_strings, 526 false) || 527 Args.hasFlag(options::OPT_mpascal_strings, 528 options::OPT_mno_pascal_strings, 529 false)) 530 CmdArgs.push_back("-fpascal-strings"); 531 532 // -fcommon is default, only pass non-default. 533 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 534 CmdArgs.push_back("-fno-common"); 535 536 // -fsigned-bitfields is default, and clang doesn't yet support 537 // --funsigned-bitfields. 538 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 539 options::OPT_funsigned_bitfields)) 540 D.Diag(clang::diag::warn_drv_clang_unsupported) 541 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 542 543 // -fdiagnostics-fixit-info is default, only pass non-default. 544 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 545 options::OPT_fno_diagnostics_fixit_info)) 546 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 547 548 // Enable -fdiagnostics-show-option by default. 549 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 550 options::OPT_fno_diagnostics_show_option)) 551 CmdArgs.push_back("-fdiagnostics-show-option"); 552 if (!Args.hasFlag(options::OPT_fcolor_diagnostics, 553 options::OPT_fno_color_diagnostics)) 554 CmdArgs.push_back("-fno-color-diagnostics"); 555 556 // -fdollars-in-identifiers default varies depending on platform and 557 // language; only pass if specified. 558 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 559 options::OPT_fno_dollars_in_identifiers)) { 560 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 561 CmdArgs.push_back("-fdollars-in-identifiers=1"); 562 else 563 CmdArgs.push_back("-fdollars-in-identifiers=0"); 564 } 565 566 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 567 // practical purposes. 568 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 569 options::OPT_fno_unit_at_a_time)) { 570 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 571 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 572 } 573 574 Args.AddLastArg(CmdArgs, options::OPT_dM); 575 Args.AddLastArg(CmdArgs, options::OPT_dD); 576 577 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 578 Args.AddAllArgValues(CmdArgs, options::OPT_mllvm); 579 580 if (Output.getType() == types::TY_Dependencies) { 581 // Handled with other dependency code. 582 } else if (Output.isPipe()) { 583 CmdArgs.push_back("-o"); 584 CmdArgs.push_back("-"); 585 } else if (Output.isFilename()) { 586 CmdArgs.push_back("-o"); 587 CmdArgs.push_back(Output.getFilename()); 588 } else { 589 assert(Output.isNothing() && "Invalid output."); 590 } 591 592 for (InputInfoList::const_iterator 593 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 594 const InputInfo &II = *it; 595 CmdArgs.push_back("-x"); 596 CmdArgs.push_back(types::getTypeName(II.getType())); 597 if (II.isPipe()) 598 CmdArgs.push_back("-"); 599 else if (II.isFilename()) 600 CmdArgs.push_back(II.getFilename()); 601 else 602 II.getInputArg().renderAsInput(Args, CmdArgs); 603 } 604 605 const char *Exec = 606 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang-cc").c_str()); 607 Dest.addCommand(new Command(Exec, CmdArgs)); 608 609 // Explicitly warn that these options are unsupported, even though 610 // we are allowing compilation to continue. 611 // FIXME: Use iterator. 612 for (ArgList::const_iterator 613 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 614 const Arg *A = *it; 615 if (A->getOption().matches(options::OPT_pg)) { 616 A->claim(); 617 D.Diag(clang::diag::warn_drv_clang_unsupported) 618 << A->getAsString(Args); 619 } 620 } 621 622 // Claim some arguments which clang supports automatically. 623 624 // -fpch-preprocess is used with gcc to add a special marker in the 625 // -output to include the PCH file. Clang's PTH solution is 626 // -completely transparent, so we do not need to deal with it at 627 // -all. 628 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 629 630 // Claim some arguments which clang doesn't support, but we don't 631 // care to warn the user about. 632 633 // FIXME: Use iterator. 634 for (ArgList::const_iterator 635 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 636 const Arg *A = *it; 637 if (A->getOption().matches(options::OPT_clang_ignored_f_Group) || 638 A->getOption().matches(options::OPT_clang_ignored_m_Group)) 639 A->claim(); 640 } 641} 642 643void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 644 Job &Dest, 645 const InputInfo &Output, 646 const InputInfoList &Inputs, 647 const ArgList &Args, 648 const char *LinkingOutput) const { 649 const Driver &D = getToolChain().getHost().getDriver(); 650 ArgStringList CmdArgs; 651 652 for (ArgList::const_iterator 653 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 654 Arg *A = *it; 655 if (A->getOption().hasForwardToGCC()) { 656 // It is unfortunate that we have to claim here, as this means 657 // we will basically never report anything interesting for 658 // platforms using a generic gcc, even if we are just using gcc 659 // to get to the assembler. 660 A->claim(); 661 A->render(Args, CmdArgs); 662 } 663 } 664 665 RenderExtraToolArgs(CmdArgs); 666 667 // If using a driver driver, force the arch. 668 const std::string &Arch = getToolChain().getArchName(); 669 if (getToolChain().getHost().useDriverDriver()) { 670 CmdArgs.push_back("-arch"); 671 672 // FIXME: Remove these special cases. 673 if (Arch == "powerpc") 674 CmdArgs.push_back("ppc"); 675 else if (Arch == "powerpc64") 676 CmdArgs.push_back("ppc64"); 677 else 678 CmdArgs.push_back(Args.MakeArgString(Arch.c_str())); 679 } 680 681 // Try to force gcc to match the tool chain we want, if we recognize 682 // the arch. 683 // 684 // FIXME: The triple class should directly provide the information we want 685 // here. 686 if (Arch == "i386" || Arch == "powerpc") 687 CmdArgs.push_back("-m32"); 688 else if (Arch == "x86_64" || Arch == "powerpc64") 689 CmdArgs.push_back("-m64"); 690 691 if (Output.isPipe()) { 692 CmdArgs.push_back("-o"); 693 CmdArgs.push_back("-"); 694 } else if (Output.isFilename()) { 695 CmdArgs.push_back("-o"); 696 CmdArgs.push_back(Output.getFilename()); 697 } else { 698 assert(Output.isNothing() && "Unexpected output"); 699 CmdArgs.push_back("-fsyntax-only"); 700 } 701 702 703 // Only pass -x if gcc will understand it; otherwise hope gcc 704 // understands the suffix correctly. The main use case this would go 705 // wrong in is for linker inputs if they happened to have an odd 706 // suffix; really the only way to get this to happen is a command 707 // like '-x foobar a.c' which will treat a.c like a linker input. 708 // 709 // FIXME: For the linker case specifically, can we safely convert 710 // inputs into '-Wl,' options? 711 for (InputInfoList::const_iterator 712 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 713 const InputInfo &II = *it; 714 715 // Don't try to pass LLVM inputs to a generic gcc. 716 if (II.getType() == types::TY_LLVMBC) 717 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 718 << getToolChain().getTripleString().c_str(); 719 720 if (types::canTypeBeUserSpecified(II.getType())) { 721 CmdArgs.push_back("-x"); 722 CmdArgs.push_back(types::getTypeName(II.getType())); 723 } 724 725 if (II.isPipe()) 726 CmdArgs.push_back("-"); 727 else if (II.isFilename()) 728 CmdArgs.push_back(II.getFilename()); 729 else 730 // Don't render as input, we need gcc to do the translations. 731 II.getInputArg().render(Args, CmdArgs); 732 } 733 734 const char *GCCName = 735 getToolChain().getHost().getDriver().CCCGenericGCCName.c_str(); 736 const char *Exec = 737 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName).c_str()); 738 Dest.addCommand(new Command(Exec, CmdArgs)); 739} 740 741void gcc::Preprocess::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 742 CmdArgs.push_back("-E"); 743} 744 745void gcc::Precompile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 746 // The type is good enough. 747} 748 749void gcc::Compile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 750 CmdArgs.push_back("-S"); 751} 752 753void gcc::Assemble::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 754 CmdArgs.push_back("-c"); 755} 756 757void gcc::Link::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 758 // The types are (hopefully) good enough. 759} 760 761const char *darwin::CC1::getCC1Name(types::ID Type) const { 762 switch (Type) { 763 default: 764 assert(0 && "Unexpected type for Darwin CC1 tool."); 765 case types::TY_Asm: 766 case types::TY_C: case types::TY_CHeader: 767 case types::TY_PP_C: case types::TY_PP_CHeader: 768 return "cc1"; 769 case types::TY_ObjC: case types::TY_ObjCHeader: 770 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 771 return "cc1obj"; 772 case types::TY_CXX: case types::TY_CXXHeader: 773 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 774 return "cc1plus"; 775 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 776 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 777 return "cc1objplus"; 778 } 779} 780 781const char *darwin::CC1::getBaseInputName(const ArgList &Args, 782 const InputInfoList &Inputs) { 783 llvm::sys::Path P(Inputs[0].getBaseInput()); 784 return Args.MakeArgString(P.getLast().c_str()); 785} 786 787const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 788 const InputInfoList &Inputs) { 789 const char *Str = getBaseInputName(Args, Inputs); 790 791 if (const char *End = strchr(Str, '.')) 792 return Args.MakeArgString(std::string(Str, End).c_str()); 793 794 return Str; 795} 796 797const char * 798darwin::CC1::getDependencyFileName(const ArgList &Args, 799 const InputInfoList &Inputs) { 800 // FIXME: Think about this more. 801 std::string Res; 802 803 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 804 std::string Str(OutputOpt->getValue(Args)); 805 806 Res = Str.substr(0, Str.rfind('.')); 807 } else 808 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 809 810 return Args.MakeArgString((Res + ".d").c_str()); 811} 812 813void darwin::CC1::AddCC1Args(const ArgList &Args, 814 ArgStringList &CmdArgs) const { 815 // Derived from cc1 spec. 816 817 // FIXME: -fapple-kext seems to disable this too. Investigate. 818 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 819 !Args.hasArg(options::OPT_mdynamic_no_pic)) 820 CmdArgs.push_back("-fPIC"); 821 822 // gcc has some code here to deal with when no -mmacosx-version-min 823 // and no -miphoneos-version-min is present, but this never happens 824 // due to tool chain specific argument translation. 825 826 // FIXME: Remove mthumb 827 // FIXME: Remove mno-thumb 828 // FIXME: Remove faltivec 829 // FIXME: Remove mno-fused-madd 830 // FIXME: Remove mlong-branch 831 // FIXME: Remove mlongcall 832 // FIXME: Remove mcpu=G4 833 // FIXME: Remove mcpu=G5 834 835 if (Args.hasArg(options::OPT_g_Flag) && 836 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 837 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 838} 839 840void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 841 const InputInfoList &Inputs, 842 const ArgStringList &OutputArgs) const { 843 const Driver &D = getToolChain().getHost().getDriver(); 844 845 // Derived from cc1_options spec. 846 if (Args.hasArg(options::OPT_fast) || 847 Args.hasArg(options::OPT_fastf) || 848 Args.hasArg(options::OPT_fastcp)) 849 CmdArgs.push_back("-O3"); 850 851 if (Arg *A = Args.getLastArg(options::OPT_pg)) 852 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 853 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 854 << A->getAsString(Args) << "-fomit-frame-pointer"; 855 856 AddCC1Args(Args, CmdArgs); 857 858 if (!Args.hasArg(options::OPT_Q)) 859 CmdArgs.push_back("-quiet"); 860 861 CmdArgs.push_back("-dumpbase"); 862 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 863 864 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 865 866 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 867 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 868 869 // FIXME: The goal is to use the user provided -o if that is our 870 // final output, otherwise to drive from the original input 871 // name. Find a clean way to go about this. 872 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 873 Args.hasArg(options::OPT_o)) { 874 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 875 CmdArgs.push_back("-auxbase-strip"); 876 CmdArgs.push_back(OutputOpt->getValue(Args)); 877 } else { 878 CmdArgs.push_back("-auxbase"); 879 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 880 } 881 882 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 883 884 Args.AddAllArgs(CmdArgs, options::OPT_O); 885 // FIXME: -Wall is getting some special treatment. Investigate. 886 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 887 Args.AddLastArg(CmdArgs, options::OPT_w); 888 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 889 options::OPT_trigraphs); 890 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 891 // Honor -std-default. 892 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 893 "-std=", /*Joined=*/true); 894 } 895 896 if (Args.hasArg(options::OPT_v)) 897 CmdArgs.push_back("-version"); 898 if (Args.hasArg(options::OPT_pg)) 899 CmdArgs.push_back("-p"); 900 Args.AddLastArg(CmdArgs, options::OPT_p); 901 902 // The driver treats -fsyntax-only specially. 903 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 904 905 Args.AddAllArgs(CmdArgs, options::OPT_undef); 906 if (Args.hasArg(options::OPT_Qn)) 907 CmdArgs.push_back("-fno-ident"); 908 909 // FIXME: This isn't correct. 910 //Args.AddLastArg(CmdArgs, options::OPT__help) 911 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 912 913 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 914 915 // FIXME: Still don't get what is happening here. Investigate. 916 Args.AddAllArgs(CmdArgs, options::OPT__param); 917 918 if (Args.hasArg(options::OPT_fmudflap) || 919 Args.hasArg(options::OPT_fmudflapth)) { 920 CmdArgs.push_back("-fno-builtin"); 921 CmdArgs.push_back("-fno-merge-constants"); 922 } 923 924 if (Args.hasArg(options::OPT_coverage)) { 925 CmdArgs.push_back("-fprofile-arcs"); 926 CmdArgs.push_back("-ftest-coverage"); 927 } 928 929 if (types::isCXX(Inputs[0].getType())) 930 CmdArgs.push_back("-D__private_extern__=extern"); 931} 932 933void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 934 const InputInfoList &Inputs, 935 const ArgStringList &OutputArgs) const { 936 // Derived from cpp_options 937 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 938 939 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 940 941 AddCC1Args(Args, CmdArgs); 942 943 // NOTE: The code below has some commonality with cpp_options, but 944 // in classic gcc style ends up sending things in different 945 // orders. This may be a good merge candidate once we drop pedantic 946 // compatibility. 947 948 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 949 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 950 options::OPT_trigraphs); 951 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 952 // Honor -std-default. 953 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 954 "-std=", /*Joined=*/true); 955 } 956 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 957 Args.AddLastArg(CmdArgs, options::OPT_w); 958 959 // The driver treats -fsyntax-only specially. 960 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 961 962 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 963 !Args.hasArg(options::OPT_fno_working_directory)) 964 CmdArgs.push_back("-fworking-directory"); 965 966 Args.AddAllArgs(CmdArgs, options::OPT_O); 967 Args.AddAllArgs(CmdArgs, options::OPT_undef); 968 if (Args.hasArg(options::OPT_save_temps)) 969 CmdArgs.push_back("-fpch-preprocess"); 970} 971 972void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 973 ArgStringList &CmdArgs, 974 const InputInfoList &Inputs) const 975{ 976 const Driver &D = getToolChain().getHost().getDriver(); 977 978 // Derived from cpp_unique_options. 979 Arg *A; 980 if ((A = Args.getLastArg(options::OPT_C)) || 981 (A = Args.getLastArg(options::OPT_CC))) { 982 if (!Args.hasArg(options::OPT_E)) 983 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 984 << A->getAsString(Args) << "-E"; 985 } 986 if (!Args.hasArg(options::OPT_Q)) 987 CmdArgs.push_back("-quiet"); 988 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 989 Args.AddLastArg(CmdArgs, options::OPT_v); 990 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 991 Args.AddLastArg(CmdArgs, options::OPT_P); 992 993 // FIXME: Handle %I properly. 994 if (getToolChain().getArchName() == "x86_64") { 995 CmdArgs.push_back("-imultilib"); 996 CmdArgs.push_back("x86_64"); 997 } 998 999 if (Args.hasArg(options::OPT_MD)) { 1000 CmdArgs.push_back("-MD"); 1001 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1002 } 1003 1004 if (Args.hasArg(options::OPT_MMD)) { 1005 CmdArgs.push_back("-MMD"); 1006 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1007 } 1008 1009 Args.AddLastArg(CmdArgs, options::OPT_M); 1010 Args.AddLastArg(CmdArgs, options::OPT_MM); 1011 Args.AddAllArgs(CmdArgs, options::OPT_MF); 1012 Args.AddLastArg(CmdArgs, options::OPT_MG); 1013 Args.AddLastArg(CmdArgs, options::OPT_MP); 1014 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 1015 Args.AddAllArgs(CmdArgs, options::OPT_MT); 1016 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 1017 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 1018 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1019 CmdArgs.push_back("-MQ"); 1020 CmdArgs.push_back(OutputOpt->getValue(Args)); 1021 } 1022 } 1023 1024 Args.AddLastArg(CmdArgs, options::OPT_remap); 1025 if (Args.hasArg(options::OPT_g3)) 1026 CmdArgs.push_back("-dD"); 1027 Args.AddLastArg(CmdArgs, options::OPT_H); 1028 1029 AddCPPArgs(Args, CmdArgs); 1030 1031 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 1032 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 1033 1034 for (InputInfoList::const_iterator 1035 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1036 const InputInfo &II = *it; 1037 1038 if (II.isPipe()) 1039 CmdArgs.push_back("-"); 1040 else 1041 CmdArgs.push_back(II.getFilename()); 1042 } 1043 1044 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1045 options::OPT_Xpreprocessor); 1046 1047 if (Args.hasArg(options::OPT_fmudflap)) { 1048 CmdArgs.push_back("-D_MUDFLAP"); 1049 CmdArgs.push_back("-include"); 1050 CmdArgs.push_back("mf-runtime.h"); 1051 } 1052 1053 if (Args.hasArg(options::OPT_fmudflapth)) { 1054 CmdArgs.push_back("-D_MUDFLAP"); 1055 CmdArgs.push_back("-D_MUDFLAPTH"); 1056 CmdArgs.push_back("-include"); 1057 CmdArgs.push_back("mf-runtime.h"); 1058 } 1059} 1060 1061void darwin::CC1::AddCPPArgs(const ArgList &Args, 1062 ArgStringList &CmdArgs) const { 1063 // Derived from cpp spec. 1064 1065 if (Args.hasArg(options::OPT_static)) { 1066 // The gcc spec is broken here, it refers to dynamic but 1067 // that has been translated. Start by being bug compatible. 1068 1069 // if (!Args.hasArg(arglist.parser.dynamicOption)) 1070 CmdArgs.push_back("-D__STATIC__"); 1071 } else 1072 CmdArgs.push_back("-D__DYNAMIC__"); 1073 1074 if (Args.hasArg(options::OPT_pthread)) 1075 CmdArgs.push_back("-D_REENTRANT"); 1076} 1077 1078void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 1079 Job &Dest, const InputInfo &Output, 1080 const InputInfoList &Inputs, 1081 const ArgList &Args, 1082 const char *LinkingOutput) const { 1083 ArgStringList CmdArgs; 1084 1085 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1086 1087 CmdArgs.push_back("-E"); 1088 1089 if (Args.hasArg(options::OPT_traditional) || 1090 Args.hasArg(options::OPT_ftraditional) || 1091 Args.hasArg(options::OPT_traditional_cpp)) 1092 CmdArgs.push_back("-traditional-cpp"); 1093 1094 ArgStringList OutputArgs; 1095 if (Output.isFilename()) { 1096 OutputArgs.push_back("-o"); 1097 OutputArgs.push_back(Output.getFilename()); 1098 } else { 1099 assert(Output.isPipe() && "Unexpected CC1 output."); 1100 } 1101 1102 if (Args.hasArg(options::OPT_E)) { 1103 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1104 } else { 1105 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1106 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1107 } 1108 1109 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1110 1111 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1112 const char *Exec = 1113 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str()); 1114 Dest.addCommand(new Command(Exec, CmdArgs)); 1115} 1116 1117void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 1118 Job &Dest, const InputInfo &Output, 1119 const InputInfoList &Inputs, 1120 const ArgList &Args, 1121 const char *LinkingOutput) const { 1122 const Driver &D = getToolChain().getHost().getDriver(); 1123 ArgStringList CmdArgs; 1124 1125 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1126 1127 types::ID InputType = Inputs[0].getType(); 1128 const Arg *A; 1129 if ((A = Args.getLastArg(options::OPT_traditional)) || 1130 (A = Args.getLastArg(options::OPT_ftraditional))) 1131 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1132 << A->getAsString(Args) << "-E"; 1133 1134 if (Output.getType() == types::TY_LLVMAsm) 1135 CmdArgs.push_back("-emit-llvm"); 1136 else if (Output.getType() == types::TY_LLVMBC) 1137 CmdArgs.push_back("-emit-llvm-bc"); 1138 1139 ArgStringList OutputArgs; 1140 if (Output.getType() != types::TY_PCH) { 1141 OutputArgs.push_back("-o"); 1142 if (Output.isPipe()) 1143 OutputArgs.push_back("-"); 1144 else if (Output.isNothing()) 1145 OutputArgs.push_back("/dev/null"); 1146 else 1147 OutputArgs.push_back(Output.getFilename()); 1148 } 1149 1150 // There is no need for this level of compatibility, but it makes 1151 // diffing easier. 1152 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 1153 Args.hasArg(options::OPT_S)); 1154 1155 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 1156 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1157 if (OutputArgsEarly) { 1158 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1159 } else { 1160 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1161 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1162 } 1163 } else { 1164 CmdArgs.push_back("-fpreprocessed"); 1165 1166 // FIXME: There is a spec command to remove 1167 // -fpredictive-compilation args here. Investigate. 1168 1169 for (InputInfoList::const_iterator 1170 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1171 const InputInfo &II = *it; 1172 1173 if (II.isPipe()) 1174 CmdArgs.push_back("-"); 1175 else 1176 CmdArgs.push_back(II.getFilename()); 1177 } 1178 1179 if (OutputArgsEarly) { 1180 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1181 } else { 1182 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1183 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1184 } 1185 } 1186 1187 if (Output.getType() == types::TY_PCH) { 1188 assert(Output.isFilename() && "Invalid PCH output."); 1189 1190 CmdArgs.push_back("-o"); 1191 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 1192 // to be a good reason. 1193 CmdArgs.push_back("/dev/null"); 1194 1195 CmdArgs.push_back("--output-pch="); 1196 CmdArgs.push_back(Output.getFilename()); 1197 } 1198 1199 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1200 const char *Exec = 1201 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name).c_str()); 1202 Dest.addCommand(new Command(Exec, CmdArgs)); 1203} 1204 1205void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1206 Job &Dest, const InputInfo &Output, 1207 const InputInfoList &Inputs, 1208 const ArgList &Args, 1209 const char *LinkingOutput) const { 1210 ArgStringList CmdArgs; 1211 1212 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1213 const InputInfo &Input = Inputs[0]; 1214 1215 // Bit of a hack, this is only used for original inputs. 1216 // 1217 // FIXME: This is broken for preprocessed .s inputs. 1218 if (Input.isFilename() && 1219 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 1220 if (Args.hasArg(options::OPT_gstabs)) 1221 CmdArgs.push_back("--gstabs"); 1222 else if (Args.hasArg(options::OPT_g_Group)) 1223 CmdArgs.push_back("--gdwarf2"); 1224 } 1225 1226 // Derived from asm spec. 1227 CmdArgs.push_back("-arch"); 1228 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName().c_str())); 1229 1230 CmdArgs.push_back("-force_cpusubtype_ALL"); 1231 if ((Args.hasArg(options::OPT_mkernel) || 1232 Args.hasArg(options::OPT_static) || 1233 Args.hasArg(options::OPT_fapple_kext)) && 1234 !Args.hasArg(options::OPT_dynamic)) 1235 CmdArgs.push_back("-static"); 1236 1237 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1238 options::OPT_Xassembler); 1239 1240 assert(Output.isFilename() && "Unexpected lipo output."); 1241 CmdArgs.push_back("-o"); 1242 CmdArgs.push_back(Output.getFilename()); 1243 1244 if (Input.isPipe()) { 1245 CmdArgs.push_back("-"); 1246 } else { 1247 assert(Input.isFilename() && "Invalid input."); 1248 CmdArgs.push_back(Input.getFilename()); 1249 } 1250 1251 // asm_final spec is empty. 1252 1253 const char *Exec = 1254 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1255 Dest.addCommand(new Command(Exec, CmdArgs)); 1256} 1257 1258/// Helper routine for seeing if we should use dsymutil; this is a 1259/// gcc compatible hack, we should remove it and use the input 1260/// type information. 1261static bool isSourceSuffix(const char *Str) { 1262 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm', 1263 // 'mm'. 1264 switch (strlen(Str)) { 1265 default: 1266 return false; 1267 case 1: 1268 return (memcmp(Str, "C", 1) == 0 || 1269 memcmp(Str, "c", 1) == 0 || 1270 memcmp(Str, "m", 1) == 0); 1271 case 2: 1272 return (memcmp(Str, "cc", 2) == 0 || 1273 memcmp(Str, "cp", 2) == 0 || 1274 memcmp(Str, "mm", 2) == 0); 1275 case 3: 1276 return (memcmp(Str, "CPP", 3) == 0 || 1277 memcmp(Str, "c++", 3) == 0 || 1278 memcmp(Str, "cpp", 3) == 0 || 1279 memcmp(Str, "cxx", 3) == 0); 1280 } 1281} 1282 1283static bool isMacosxVersionLT(unsigned (&A)[3], unsigned (&B)[3]) { 1284 for (unsigned i=0; i < 3; ++i) { 1285 if (A[i] > B[i]) return false; 1286 if (A[i] < B[i]) return true; 1287 } 1288 return false; 1289} 1290 1291static bool isMacosxVersionLT(unsigned (&A)[3], 1292 unsigned V0, unsigned V1=0, unsigned V2=0) { 1293 unsigned B[3] = { V0, V1, V2 }; 1294 return isMacosxVersionLT(A, B); 1295} 1296 1297const toolchains::Darwin_X86 &darwin::Link::getDarwinToolChain() const { 1298 return reinterpret_cast<const toolchains::Darwin_X86&>(getToolChain()); 1299} 1300 1301void darwin::Link::AddDarwinArch(const ArgList &Args, 1302 ArgStringList &CmdArgs) const { 1303 // Derived from darwin_arch spec. 1304 CmdArgs.push_back("-arch"); 1305 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName().c_str())); 1306} 1307 1308void darwin::Link::AddDarwinSubArch(const ArgList &Args, 1309 ArgStringList &CmdArgs) const { 1310 // Derived from darwin_subarch spec, not sure what the distinction 1311 // exists for but at least for this chain it is the same. 1312 AddDarwinArch(Args, CmdArgs); 1313} 1314 1315void darwin::Link::AddLinkArgs(const ArgList &Args, 1316 ArgStringList &CmdArgs) const { 1317 const Driver &D = getToolChain().getHost().getDriver(); 1318 1319 // Derived from the "link" spec. 1320 Args.AddAllArgs(CmdArgs, options::OPT_static); 1321 if (!Args.hasArg(options::OPT_static)) 1322 CmdArgs.push_back("-dynamic"); 1323 if (Args.hasArg(options::OPT_fgnu_runtime)) { 1324 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 1325 // here. How do we wish to handle such things? 1326 } 1327 1328 if (!Args.hasArg(options::OPT_dynamiclib)) { 1329 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1330 AddDarwinArch(Args, CmdArgs); 1331 CmdArgs.push_back("-force_cpusubtype_ALL"); 1332 } else 1333 AddDarwinSubArch(Args, CmdArgs); 1334 1335 Args.AddLastArg(CmdArgs, options::OPT_bundle); 1336 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 1337 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 1338 1339 Arg *A; 1340 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 1341 (A = Args.getLastArg(options::OPT_current__version)) || 1342 (A = Args.getLastArg(options::OPT_install__name))) 1343 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1344 << A->getAsString(Args) << "-dynamiclib"; 1345 1346 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 1347 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 1348 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 1349 } else { 1350 CmdArgs.push_back("-dylib"); 1351 1352 Arg *A; 1353 if ((A = Args.getLastArg(options::OPT_bundle)) || 1354 (A = Args.getLastArg(options::OPT_bundle__loader)) || 1355 (A = Args.getLastArg(options::OPT_client__name)) || 1356 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 1357 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 1358 (A = Args.getLastArg(options::OPT_private__bundle))) 1359 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1360 << A->getAsString(Args) << "-dynamiclib"; 1361 1362 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 1363 "-dylib_compatibility_version"); 1364 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 1365 "-dylib_current_version"); 1366 1367 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1368 AddDarwinArch(Args, CmdArgs); 1369 // NOTE: We don't add -force_cpusubtype_ALL on this path. Ok. 1370 } else 1371 AddDarwinSubArch(Args, CmdArgs); 1372 1373 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 1374 "-dylib_install_name"); 1375 } 1376 1377 Args.AddLastArg(CmdArgs, options::OPT_all__load); 1378 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 1379 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 1380 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 1381 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 1382 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 1383 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 1384 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 1385 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 1386 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 1387 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 1388 Args.AddAllArgs(CmdArgs, options::OPT_init); 1389 1390 if (!Args.hasArg(options::OPT_mmacosx_version_min_EQ)) { 1391 if (!Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 1392 // FIXME: I don't understand what is going on here. This is 1393 // supposed to come from darwin_ld_minversion, but gcc doesn't 1394 // seem to be following that; it must be getting overridden 1395 // somewhere. 1396 CmdArgs.push_back("-macosx_version_min"); 1397 CmdArgs.push_back(getDarwinToolChain().getMacosxVersionStr()); 1398 } 1399 } else { 1400 // Adding all arguments doesn't make sense here but this is what 1401 // gcc does. 1402 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 1403 "-macosx_version_min"); 1404 } 1405 1406 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 1407 "-iphoneos_version_min"); 1408 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 1409 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 1410 Args.AddLastArg(CmdArgs, options::OPT_single__module); 1411 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 1412 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 1413 1414 if (Args.hasArg(options::OPT_fpie)) 1415 CmdArgs.push_back("-pie"); 1416 1417 Args.AddLastArg(CmdArgs, options::OPT_prebind); 1418 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 1419 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 1420 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 1421 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 1422 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 1423 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 1424 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 1425 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 1426 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 1427 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 1428 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 1429 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 1430 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 1431 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 1432 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 1433 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 1434 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 1435 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 1436 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 1437 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 1438 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 1439 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 1440 1441 if (!Args.hasArg(options::OPT_weak__reference__mismatches)) { 1442 CmdArgs.push_back("-weak_reference_mismatches"); 1443 CmdArgs.push_back("non-weak"); 1444 } 1445 1446 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 1447 Args.AddAllArgs(CmdArgs, options::OPT_y); 1448 Args.AddLastArg(CmdArgs, options::OPT_w); 1449 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 1450 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 1451 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 1452 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 1453 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 1454 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 1455 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 1456 Args.AddLastArg(CmdArgs, options::OPT_whyload); 1457 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 1458 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 1459 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 1460 Args.AddLastArg(CmdArgs, options::OPT_Mach); 1461} 1462 1463void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 1464 Job &Dest, const InputInfo &Output, 1465 const InputInfoList &Inputs, 1466 const ArgList &Args, 1467 const char *LinkingOutput) const { 1468 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 1469 // The logic here is derived from gcc's behavior; most of which 1470 // comes from specs (starting with link_command). Consult gcc for 1471 // more information. 1472 1473 // FIXME: The spec references -fdump= which seems to have 1474 // disappeared? 1475 1476 ArgStringList CmdArgs; 1477 1478 // I'm not sure why this particular decomposition exists in gcc, but 1479 // we follow suite for ease of comparison. 1480 AddLinkArgs(Args, CmdArgs); 1481 1482 // FIXME: gcc has %{x} in here. How could this ever happen? Cruft? 1483 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 1484 Args.AddAllArgs(CmdArgs, options::OPT_s); 1485 Args.AddAllArgs(CmdArgs, options::OPT_t); 1486 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 1487 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 1488 Args.AddAllArgs(CmdArgs, options::OPT_A); 1489 Args.AddLastArg(CmdArgs, options::OPT_e); 1490 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 1491 Args.AddAllArgs(CmdArgs, options::OPT_r); 1492 1493 // FIXME: This is just being pedantically bug compatible, gcc 1494 // doesn't *mean* to forward this, it just does (yay for pattern 1495 // matching). It doesn't work, of course. 1496 Args.AddAllArgs(CmdArgs, options::OPT_object); 1497 1498 CmdArgs.push_back("-o"); 1499 CmdArgs.push_back(Output.getFilename()); 1500 1501 unsigned MacosxVersion[3]; 1502 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) { 1503 bool HadExtra; 1504 if (!Driver::GetReleaseVersion(A->getValue(Args), MacosxVersion[0], 1505 MacosxVersion[1], MacosxVersion[2], 1506 HadExtra) || 1507 HadExtra) { 1508 const Driver &D = getToolChain().getHost().getDriver(); 1509 D.Diag(clang::diag::err_drv_invalid_version_number) 1510 << A->getAsString(Args); 1511 } 1512 } else { 1513 getDarwinToolChain().getMacosxVersion(MacosxVersion); 1514 } 1515 1516 if (!Args.hasArg(options::OPT_A) && 1517 !Args.hasArg(options::OPT_nostdlib) && 1518 !Args.hasArg(options::OPT_nostartfiles)) { 1519 // Derived from startfile spec. 1520 if (Args.hasArg(options::OPT_dynamiclib)) { 1521 // Derived from darwin_dylib1 spec. 1522 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1523 CmdArgs.push_back("-ldylib1.o"); 1524 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1525 CmdArgs.push_back("-ldylib1.10.5.o"); 1526 } else { 1527 if (Args.hasArg(options::OPT_bundle)) { 1528 if (!Args.hasArg(options::OPT_static)) { 1529 // Derived from darwin_bundle1 spec. 1530 if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1531 CmdArgs.push_back("-lbundle1.o"); 1532 } 1533 } else { 1534 if (Args.hasArg(options::OPT_pg)) { 1535 if (Args.hasArg(options::OPT_static) || 1536 Args.hasArg(options::OPT_object) || 1537 Args.hasArg(options::OPT_preload)) { 1538 CmdArgs.push_back("-lgcrt0.o"); 1539 } else { 1540 CmdArgs.push_back("-lgcrt1.o"); 1541 1542 // darwin_crt2 spec is empty. 1543 } 1544 } else { 1545 if (Args.hasArg(options::OPT_static) || 1546 Args.hasArg(options::OPT_object) || 1547 Args.hasArg(options::OPT_preload)) { 1548 CmdArgs.push_back("-lcrt0.o"); 1549 } else { 1550 // Derived from darwin_crt1 spec. 1551 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1552 CmdArgs.push_back("-lcrt1.o"); 1553 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1554 CmdArgs.push_back("-lcrt1.10.5.o"); 1555 else 1556 CmdArgs.push_back("-lcrt1.10.6.o"); 1557 1558 // darwin_crt2 spec is empty. 1559 } 1560 } 1561 } 1562 } 1563 1564 if (Args.hasArg(options::OPT_shared_libgcc) && 1565 !Args.hasArg(options::OPT_miphoneos_version_min_EQ) && 1566 isMacosxVersionLT(MacosxVersion, 10, 5)) { 1567 const char *Str = getToolChain().GetFilePath(C, "crt3.o").c_str(); 1568 CmdArgs.push_back(Args.MakeArgString(Str)); 1569 } 1570 } 1571 1572 Args.AddAllArgs(CmdArgs, options::OPT_L); 1573 1574 if (Args.hasArg(options::OPT_fopenmp)) 1575 // This is more complicated in gcc... 1576 CmdArgs.push_back("-lgomp"); 1577 1578 // FIXME: Derive these correctly. 1579 const char *TCDir = getDarwinToolChain().getToolChainDir().c_str(); 1580 if (getToolChain().getArchName() == "x86_64") { 1581 CmdArgs.push_back(MakeFormattedString(Args, 1582 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir))); 1583 // Intentionally duplicated for (temporary) gcc bug compatibility. 1584 CmdArgs.push_back(MakeFormattedString(Args, 1585 llvm::format("-L/usr/lib/gcc/%s/x86_64", TCDir))); 1586 } 1587 CmdArgs.push_back(MakeFormattedString(Args, 1588 llvm::format("-L/usr/lib/%s", TCDir))); 1589 CmdArgs.push_back(MakeFormattedString(Args, 1590 llvm::format("-L/usr/lib/gcc/%s", TCDir))); 1591 // Intentionally duplicated for (temporary) gcc bug compatibility. 1592 CmdArgs.push_back(MakeFormattedString(Args, 1593 llvm::format("-L/usr/lib/gcc/%s", TCDir))); 1594 CmdArgs.push_back(MakeFormattedString(Args, 1595 llvm::format("-L/usr/lib/gcc/%s/../../../%s", TCDir, TCDir))); 1596 CmdArgs.push_back(MakeFormattedString(Args, 1597 llvm::format("-L/usr/lib/gcc/%s/../../..", TCDir))); 1598 1599 for (InputInfoList::const_iterator 1600 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1601 const InputInfo &II = *it; 1602 if (II.isFilename()) 1603 CmdArgs.push_back(II.getFilename()); 1604 else 1605 II.getInputArg().renderAsInput(Args, CmdArgs); 1606 } 1607 1608 if (LinkingOutput) { 1609 CmdArgs.push_back("-arch_multiple"); 1610 CmdArgs.push_back("-final_output"); 1611 CmdArgs.push_back(LinkingOutput); 1612 } 1613 1614 if (Args.hasArg(options::OPT_fprofile_arcs) || 1615 Args.hasArg(options::OPT_fprofile_generate) || 1616 Args.hasArg(options::OPT_fcreate_profile) || 1617 Args.hasArg(options::OPT_coverage)) 1618 CmdArgs.push_back("-lgcov"); 1619 1620 if (Args.hasArg(options::OPT_fnested_functions)) 1621 CmdArgs.push_back("-allow_stack_execute"); 1622 1623 if (!Args.hasArg(options::OPT_nostdlib) && 1624 !Args.hasArg(options::OPT_nodefaultlibs)) { 1625 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 1626 // before -lm, for example. 1627 if (getToolChain().getHost().getDriver().CCCIsCXX) 1628 CmdArgs.push_back("-lstdc++"); 1629 1630 // link_ssp spec is empty. 1631 1632 // Derived from libgcc and lib specs but refactored. 1633 if (Args.hasArg(options::OPT_static)) { 1634 CmdArgs.push_back("-lgcc_static"); 1635 } else { 1636 if (Args.hasArg(options::OPT_static_libgcc)) { 1637 CmdArgs.push_back("-lgcc_eh"); 1638 } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 1639 // Derived from darwin_iphoneos_libgcc spec. 1640 CmdArgs.push_back("-lgcc_s.10.5"); 1641 } else if (Args.hasArg(options::OPT_shared_libgcc) || 1642 Args.hasArg(options::OPT_fexceptions) || 1643 Args.hasArg(options::OPT_fgnu_runtime)) { 1644 // FIXME: This is probably broken on 10.3? 1645 if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1646 CmdArgs.push_back("-lgcc_s.10.4"); 1647 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1648 CmdArgs.push_back("-lgcc_s.10.5"); 1649 } else { 1650 if (isMacosxVersionLT(MacosxVersion, 10, 3, 9)) 1651 ; // Do nothing. 1652 else if (isMacosxVersionLT(MacosxVersion, 10, 5)) 1653 CmdArgs.push_back("-lgcc_s.10.4"); 1654 else if (isMacosxVersionLT(MacosxVersion, 10, 6)) 1655 CmdArgs.push_back("-lgcc_s.10.5"); 1656 } 1657 1658 if (isMacosxVersionLT(MacosxVersion, 10, 6)) { 1659 CmdArgs.push_back("-lgcc"); 1660 CmdArgs.push_back("-lSystem"); 1661 } else { 1662 CmdArgs.push_back("-lSystem"); 1663 CmdArgs.push_back("-lgcc"); 1664 } 1665 } 1666 } 1667 1668 if (!Args.hasArg(options::OPT_A) && 1669 !Args.hasArg(options::OPT_nostdlib) && 1670 !Args.hasArg(options::OPT_nostartfiles)) { 1671 // endfile_spec is empty. 1672 } 1673 1674 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1675 Args.AddAllArgs(CmdArgs, options::OPT_F); 1676 1677 const char *Exec = 1678 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 1679 Dest.addCommand(new Command(Exec, CmdArgs)); 1680 1681 // Find the first non-empty base input (we want to ignore linker 1682 // inputs). 1683 const char *BaseInput = ""; 1684 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1685 if (Inputs[i].getBaseInput()[0] != '\0') { 1686 BaseInput = Inputs[i].getBaseInput(); 1687 break; 1688 } 1689 } 1690 1691 // Run dsymutil if we are making an executable in a single step. 1692 // 1693 // FIXME: Currently we don't want to do this when we are part of a 1694 // universal build step, as this would end up creating stray temp 1695 // files. 1696 if (!LinkingOutput && 1697 Args.getLastArg(options::OPT_g_Group) && 1698 !Args.getLastArg(options::OPT_gstabs) && 1699 !Args.getLastArg(options::OPT_g0)) { 1700 // FIXME: This is gross, but matches gcc. The test only considers 1701 // the suffix (not the -x type), and then only of the first 1702 // source input. Awesome. 1703 const char *Suffix = strrchr(BaseInput, '.'); 1704 if (Suffix && isSourceSuffix(Suffix + 1)) { 1705 const char *Exec = 1706 Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil").c_str()); 1707 ArgStringList CmdArgs; 1708 CmdArgs.push_back(Output.getFilename()); 1709 C.getJobs().addCommand(new Command(Exec, CmdArgs)); 1710 } 1711 } 1712} 1713 1714void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 1715 Job &Dest, const InputInfo &Output, 1716 const InputInfoList &Inputs, 1717 const ArgList &Args, 1718 const char *LinkingOutput) const { 1719 ArgStringList CmdArgs; 1720 1721 CmdArgs.push_back("-create"); 1722 assert(Output.isFilename() && "Unexpected lipo output."); 1723 1724 CmdArgs.push_back("-output"); 1725 CmdArgs.push_back(Output.getFilename()); 1726 1727 for (InputInfoList::const_iterator 1728 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1729 const InputInfo &II = *it; 1730 assert(II.isFilename() && "Unexpected lipo input."); 1731 CmdArgs.push_back(II.getFilename()); 1732 } 1733 const char *Exec = 1734 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo").c_str()); 1735 Dest.addCommand(new Command(Exec, CmdArgs)); 1736} 1737 1738 1739void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1740 Job &Dest, const InputInfo &Output, 1741 const InputInfoList &Inputs, 1742 const ArgList &Args, 1743 const char *LinkingOutput) const 1744{ 1745 ArgStringList CmdArgs; 1746 1747 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 1748 // instruct as in the base system to assemble 32-bit code. 1749 if (getToolChain().getArchName() == "i386") 1750 CmdArgs.push_back("--32"); 1751 1752 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1753 options::OPT_Xassembler); 1754 1755 CmdArgs.push_back("-o"); 1756 if (Output.isPipe()) 1757 CmdArgs.push_back("-"); 1758 else 1759 CmdArgs.push_back(Output.getFilename()); 1760 1761 for (InputInfoList::const_iterator 1762 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1763 const InputInfo &II = *it; 1764 if (II.isPipe()) 1765 CmdArgs.push_back("-"); 1766 else 1767 CmdArgs.push_back(II.getFilename()); 1768 } 1769 1770 const char *Exec = 1771 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1772 Dest.addCommand(new Command(Exec, CmdArgs)); 1773} 1774 1775void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 1776 Job &Dest, const InputInfo &Output, 1777 const InputInfoList &Inputs, 1778 const ArgList &Args, 1779 const char *LinkingOutput) const { 1780 const Driver &D = getToolChain().getHost().getDriver(); 1781 ArgStringList CmdArgs; 1782 1783 if (Args.hasArg(options::OPT_static)) { 1784 CmdArgs.push_back("-Bstatic"); 1785 } else { 1786 CmdArgs.push_back("--eh-frame-hdr"); 1787 if (Args.hasArg(options::OPT_shared)) { 1788 CmdArgs.push_back("-Bshareable"); 1789 } else { 1790 CmdArgs.push_back("-dynamic-linker"); 1791 CmdArgs.push_back("/libexec/ld-elf.so.1"); 1792 } 1793 } 1794 1795 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 1796 // instruct ld in the base system to link 32-bit code. 1797 if (getToolChain().getArchName() == "i386") { 1798 CmdArgs.push_back("-m"); 1799 CmdArgs.push_back("elf_i386_fbsd"); 1800 } 1801 1802 if (Output.isPipe()) { 1803 CmdArgs.push_back("-o"); 1804 CmdArgs.push_back("-"); 1805 } else if (Output.isFilename()) { 1806 CmdArgs.push_back("-o"); 1807 CmdArgs.push_back(Output.getFilename()); 1808 } else { 1809 assert(Output.isNothing() && "Invalid output."); 1810 } 1811 1812 if (!Args.hasArg(options::OPT_nostdlib) && 1813 !Args.hasArg(options::OPT_nostartfiles)) { 1814 if (!Args.hasArg(options::OPT_shared)) { 1815 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o").c_str())); 1816 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1817 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o").c_str())); 1818 } else { 1819 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1820 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o").c_str())); 1821 } 1822 } 1823 1824 Args.AddAllArgs(CmdArgs, options::OPT_L); 1825 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1826 Args.AddAllArgs(CmdArgs, options::OPT_e); 1827 1828 for (InputInfoList::const_iterator 1829 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1830 const InputInfo &II = *it; 1831 1832 // Don't try to pass LLVM inputs to a generic gcc. 1833 if (II.getType() == types::TY_LLVMBC) 1834 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1835 << getToolChain().getTripleString().c_str(); 1836 1837 if (II.isPipe()) 1838 CmdArgs.push_back("-"); 1839 else if (II.isFilename()) 1840 CmdArgs.push_back(II.getFilename()); 1841 else 1842 II.getInputArg().renderAsInput(Args, CmdArgs); 1843 } 1844 1845 if (!Args.hasArg(options::OPT_nostdlib) && 1846 !Args.hasArg(options::OPT_nodefaultlibs)) { 1847 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 1848 // the default system libraries. Just mimic this for now. 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 if (Args.hasArg(options::OPT_pthread)) 1859 CmdArgs.push_back("-lpthread"); 1860 CmdArgs.push_back("-lc"); 1861 1862 CmdArgs.push_back("-lgcc"); 1863 if (Args.hasArg(options::OPT_static)) { 1864 CmdArgs.push_back("-lgcc_eh"); 1865 } else { 1866 CmdArgs.push_back("--as-needed"); 1867 CmdArgs.push_back("-lgcc_s"); 1868 CmdArgs.push_back("--no-as-needed"); 1869 } 1870 } 1871 1872 if (!Args.hasArg(options::OPT_nostdlib) && 1873 !Args.hasArg(options::OPT_nostartfiles)) { 1874 if (!Args.hasArg(options::OPT_shared)) 1875 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o").c_str())); 1876 else 1877 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o").c_str())); 1878 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o").c_str())); 1879 } 1880 1881 const char *Exec = 1882 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 1883 Dest.addCommand(new Command(Exec, CmdArgs)); 1884} 1885 1886/// DragonFly Tools 1887 1888// For now, DragonFly Assemble does just about the same as for 1889// FreeBSD, but this may change soon. 1890void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1891 Job &Dest, const InputInfo &Output, 1892 const InputInfoList &Inputs, 1893 const ArgList &Args, 1894 const char *LinkingOutput) const { 1895 ArgStringList CmdArgs; 1896 1897 // When building 32-bit code on DragonFly/pc64, we have to explicitly 1898 // instruct as in the base system to assemble 32-bit code. 1899 if (getToolChain().getArchName() == "i386") 1900 CmdArgs.push_back("--32"); 1901 1902 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1903 options::OPT_Xassembler); 1904 1905 CmdArgs.push_back("-o"); 1906 if (Output.isPipe()) 1907 CmdArgs.push_back("-"); 1908 else 1909 CmdArgs.push_back(Output.getFilename()); 1910 1911 for (InputInfoList::const_iterator 1912 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1913 const InputInfo &II = *it; 1914 if (II.isPipe()) 1915 CmdArgs.push_back("-"); 1916 else 1917 CmdArgs.push_back(II.getFilename()); 1918 } 1919 1920 const char *Exec = 1921 Args.MakeArgString(getToolChain().GetProgramPath(C, "as").c_str()); 1922 Dest.addCommand(new Command(Exec, CmdArgs)); 1923} 1924 1925void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 1926 Job &Dest, const InputInfo &Output, 1927 const InputInfoList &Inputs, 1928 const ArgList &Args, 1929 const char *LinkingOutput) const { 1930 const Driver &D = getToolChain().getHost().getDriver(); 1931 ArgStringList CmdArgs; 1932 1933 if (Args.hasArg(options::OPT_static)) { 1934 CmdArgs.push_back("-Bstatic"); 1935 } else { 1936 if (Args.hasArg(options::OPT_shared)) 1937 CmdArgs.push_back("-Bshareable"); 1938 else { 1939 CmdArgs.push_back("-dynamic-linker"); 1940 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 1941 } 1942 } 1943 1944 // When building 32-bit code on DragonFly/pc64, we have to explicitly 1945 // instruct ld in the base system to link 32-bit code. 1946 if (getToolChain().getArchName() == "i386") { 1947 CmdArgs.push_back("-m"); 1948 CmdArgs.push_back("elf_i386"); 1949 } 1950 1951 if (Output.isPipe()) { 1952 CmdArgs.push_back("-o"); 1953 CmdArgs.push_back("-"); 1954 } else if (Output.isFilename()) { 1955 CmdArgs.push_back("-o"); 1956 CmdArgs.push_back(Output.getFilename()); 1957 } else { 1958 assert(Output.isNothing() && "Invalid output."); 1959 } 1960 1961 if (!Args.hasArg(options::OPT_nostdlib) && 1962 !Args.hasArg(options::OPT_nostartfiles)) { 1963 if (!Args.hasArg(options::OPT_shared)) { 1964 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o").c_str())); 1965 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1966 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o").c_str())); 1967 } else { 1968 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o").c_str())); 1969 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o").c_str())); 1970 } 1971 } 1972 1973 Args.AddAllArgs(CmdArgs, options::OPT_L); 1974 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 1975 Args.AddAllArgs(CmdArgs, options::OPT_e); 1976 1977 for (InputInfoList::const_iterator 1978 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1979 const InputInfo &II = *it; 1980 1981 // Don't try to pass LLVM inputs to a generic gcc. 1982 if (II.getType() == types::TY_LLVMBC) 1983 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1984 << getToolChain().getTripleString().c_str(); 1985 1986 if (II.isPipe()) 1987 CmdArgs.push_back("-"); 1988 else if (II.isFilename()) 1989 CmdArgs.push_back(II.getFilename()); 1990 else 1991 II.getInputArg().renderAsInput(Args, CmdArgs); 1992 } 1993 1994 if (!Args.hasArg(options::OPT_nostdlib) && 1995 !Args.hasArg(options::OPT_nodefaultlibs)) { 1996 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 1997 // rpaths 1998 CmdArgs.push_back("-L/usr/lib/gcc41"); 1999 2000 if (!Args.hasArg(options::OPT_static)) { 2001 CmdArgs.push_back("-rpath"); 2002 CmdArgs.push_back("/usr/lib/gcc41"); 2003 2004 CmdArgs.push_back("-rpath-link"); 2005 CmdArgs.push_back("/usr/lib/gcc41"); 2006 2007 CmdArgs.push_back("-rpath"); 2008 CmdArgs.push_back("/usr/lib"); 2009 2010 CmdArgs.push_back("-rpath-link"); 2011 CmdArgs.push_back("/usr/lib"); 2012 } 2013 2014 if (Args.hasArg(options::OPT_shared)) { 2015 CmdArgs.push_back("-lgcc_pic"); 2016 } else { 2017 CmdArgs.push_back("-lgcc"); 2018 } 2019 2020 2021 if (Args.hasArg(options::OPT_pthread)) 2022 CmdArgs.push_back("-lthread_xu"); 2023 2024 if (!Args.hasArg(options::OPT_nolibc)) { 2025 CmdArgs.push_back("-lc"); 2026 } 2027 2028 if (Args.hasArg(options::OPT_shared)) { 2029 CmdArgs.push_back("-lgcc_pic"); 2030 } else { 2031 CmdArgs.push_back("-lgcc"); 2032 } 2033 } 2034 2035 if (!Args.hasArg(options::OPT_nostdlib) && 2036 !Args.hasArg(options::OPT_nostartfiles)) { 2037 if (!Args.hasArg(options::OPT_shared)) 2038 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o").c_str())); 2039 else 2040 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o").c_str())); 2041 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o").c_str())); 2042 } 2043 2044 const char *Exec = 2045 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld").c_str()); 2046 Dest.addCommand(new Command(Exec, CmdArgs)); 2047} 2048