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