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