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