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