Tools.cpp revision 199482
1101099Srwatson//===--- Tools.cpp - Tools Implementations ------------------------------*-===// 2101099Srwatson// 3101099Srwatson// The LLVM Compiler Infrastructure 4101099Srwatson// 5101099Srwatson// This file is distributed under the University of Illinois Open Source 6101099Srwatson// License. See LICENSE.TXT for details. 7101099Srwatson// 8106393Srwatson//===----------------------------------------------------------------------===// 9106393Srwatson 10106393Srwatson#include "Tools.h" 11106393Srwatson 12101099Srwatson#include "clang/Driver/Action.h" 13101099Srwatson#include "clang/Driver/Arg.h" 14101099Srwatson#include "clang/Driver/ArgList.h" 15101099Srwatson#include "clang/Driver/Driver.h" 16101099Srwatson#include "clang/Driver/DriverDiagnostic.h" 17101099Srwatson#include "clang/Driver/Compilation.h" 18101099Srwatson#include "clang/Driver/Job.h" 19101099Srwatson#include "clang/Driver/HostInfo.h" 20101099Srwatson#include "clang/Driver/Option.h" 21101099Srwatson#include "clang/Driver/ToolChain.h" 22101099Srwatson#include "clang/Driver/Util.h" 23101099Srwatson 24101099Srwatson#include "llvm/ADT/SmallString.h" 25101099Srwatson#include "llvm/ADT/StringSwitch.h" 26101099Srwatson#include "llvm/ADT/Twine.h" 27101099Srwatson#include "llvm/Support/Format.h" 28101099Srwatson#include "llvm/Support/raw_ostream.h" 29101099Srwatson#include "llvm/System/Host.h" 30101099Srwatson#include "llvm/System/Process.h" 31101099Srwatson 32101099Srwatson#include "InputInfo.h" 33101099Srwatson#include "ToolChains.h" 34101099Srwatson 35101099Srwatsonusing namespace clang::driver; 36101099Srwatsonusing namespace clang::driver::tools; 37101099Srwatson 38101099Srwatson/// CheckPreprocessingOptions - Perform some validation of preprocessing 39101099Srwatson/// arguments that is shared with gcc. 40101099Srwatsonstatic void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 41101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 42101099Srwatson if (!Args.hasArg(options::OPT_E)) 43101099Srwatson D.Diag(clang::diag::err_drv_argument_only_allowed_with) 44101099Srwatson << A->getAsString(Args) << "-E"; 45101099Srwatson} 46101099Srwatson 47101099Srwatson/// CheckCodeGenerationOptions - Perform some validation of code generation 48101099Srwatson/// arguments that is shared with gcc. 49101099Srwatsonstatic void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 50101099Srwatson // In gcc, only ARM checks this, but it seems reasonable to check universally. 51101099Srwatson if (Args.hasArg(options::OPT_static)) 52101099Srwatson if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 53101099Srwatson options::OPT_mdynamic_no_pic)) 54101099Srwatson D.Diag(clang::diag::err_drv_argument_not_allowed_with) 55101099Srwatson << A->getAsString(Args) << "-static"; 56101099Srwatson} 57101099Srwatson 58101099Srwatsonvoid Clang::AddPreprocessingOptions(const Driver &D, 59101099Srwatson const ArgList &Args, 60101099Srwatson ArgStringList &CmdArgs, 61101099Srwatson const InputInfo &Output, 62101099Srwatson const InputInfoList &Inputs) const { 63101099Srwatson Arg *A; 64101099Srwatson 65101099Srwatson CheckPreprocessingOptions(D, Args); 66101099Srwatson 67101099Srwatson Args.AddLastArg(CmdArgs, options::OPT_C); 68101099Srwatson Args.AddLastArg(CmdArgs, options::OPT_CC); 69101099Srwatson 70101099Srwatson // Handle dependency file generation. 71101099Srwatson if ((A = Args.getLastArg(options::OPT_M)) || 72101099Srwatson (A = Args.getLastArg(options::OPT_MM)) || 73101099Srwatson (A = Args.getLastArg(options::OPT_MD)) || 74101099Srwatson (A = Args.getLastArg(options::OPT_MMD))) { 75101099Srwatson // Determine the output location. 76101099Srwatson const char *DepFile; 77101099Srwatson if (Output.getType() == types::TY_Dependencies) { 78101099Srwatson if (Output.isPipe()) 79101099Srwatson DepFile = "-"; 80101099Srwatson else 81101099Srwatson DepFile = Output.getFilename(); 82101099Srwatson } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 83101099Srwatson DepFile = MF->getValue(Args); 84101099Srwatson } else if (A->getOption().getId() == options::OPT_M || 85101099Srwatson A->getOption().getId() == options::OPT_MM) { 86101099Srwatson DepFile = "-"; 87101099Srwatson } else { 88101099Srwatson DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 89101099Srwatson } 90101099Srwatson CmdArgs.push_back("-dependency-file"); 91101099Srwatson CmdArgs.push_back(DepFile); 92101099Srwatson 93101099Srwatson // Add an -MT option if the user didn't specify their own. 94101099Srwatson // 95101099Srwatson // FIXME: This should use -MQ, when we support it. 96101099Srwatson if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 97101099Srwatson const char *DepTarget; 98101099Srwatson 99101099Srwatson // If user provided -o, that is the dependency target, except 100101099Srwatson // when we are only generating a dependency file. 101101099Srwatson Arg *OutputOpt = Args.getLastArg(options::OPT_o); 102101099Srwatson if (OutputOpt && Output.getType() != types::TY_Dependencies) { 103101099Srwatson DepTarget = OutputOpt->getValue(Args); 104101099Srwatson } else { 105101099Srwatson // Otherwise derive from the base input. 106101099Srwatson // 107101099Srwatson // FIXME: This should use the computed output file location. 108101099Srwatson llvm::sys::Path P(Inputs[0].getBaseInput()); 109101099Srwatson 110101099Srwatson P.eraseSuffix(); 111101099Srwatson P.appendSuffix("o"); 112101099Srwatson DepTarget = Args.MakeArgString(P.getLast()); 113101099Srwatson } 114101099Srwatson 115101099Srwatson CmdArgs.push_back("-MT"); 116101099Srwatson CmdArgs.push_back(DepTarget); 117101099Srwatson } 118101099Srwatson 119101099Srwatson if (A->getOption().getId() == options::OPT_M || 120101099Srwatson A->getOption().getId() == options::OPT_MD) 121101099Srwatson CmdArgs.push_back("-sys-header-deps"); 122101099Srwatson } 123101099Srwatson 124101099Srwatson Args.AddLastArg(CmdArgs, options::OPT_MP); 125101099Srwatson Args.AddAllArgs(CmdArgs, options::OPT_MT); 126101099Srwatson 127101099Srwatson // Add -i* options, and automatically translate to 128101099Srwatson // -include-pch/-include-pth for transparent PCH support. It's 129101099Srwatson // wonky, but we include looking for .gch so we can support seamless 130101099Srwatson // replacement into a build system already set up to be generating 131101099Srwatson // .gch files. 132101099Srwatson // 133101099Srwatson // FIXME: Use iterator. 134101099Srwatson for (ArgList::const_iterator 135101099Srwatson it = Args.begin(), ie = Args.end(); it != ie; ++it) { 136101099Srwatson const Arg *A = *it; 137101099Srwatson if (!A->getOption().matches(options::OPT_clang_i_Group)) 138101099Srwatson continue; 139101099Srwatson 140101099Srwatson if (A->getOption().matches(options::OPT_include)) { 141101099Srwatson // Use PCH if the user requested it, except for C++ (for now). 142101099Srwatson bool UsePCH = D.CCCUsePCH; 143101099Srwatson if (types::isCXX(Inputs[0].getType())) 144101099Srwatson UsePCH = false; 145101099Srwatson 146101099Srwatson bool FoundPTH = false; 147101099Srwatson bool FoundPCH = false; 148101099Srwatson llvm::sys::Path P(A->getValue(Args)); 149101099Srwatson if (UsePCH) { 150101099Srwatson P.appendSuffix("pch"); 151101099Srwatson if (P.exists()) 152101099Srwatson FoundPCH = true; 153101099Srwatson else 154101099Srwatson P.eraseSuffix(); 155101099Srwatson } 156101099Srwatson 157101099Srwatson if (!FoundPCH) { 158101099Srwatson P.appendSuffix("pth"); 159101099Srwatson if (P.exists()) 160101099Srwatson FoundPTH = true; 161101099Srwatson else 162101099Srwatson P.eraseSuffix(); 163101099Srwatson } 164101099Srwatson 165101099Srwatson if (!FoundPCH && !FoundPTH) { 166101099Srwatson P.appendSuffix("gch"); 167111119Simp if (P.exists()) { 168101099Srwatson FoundPCH = UsePCH; 169101099Srwatson FoundPTH = !UsePCH; 170101099Srwatson } 171101099Srwatson else 172101099Srwatson P.eraseSuffix(); 173101099Srwatson } 174101099Srwatson 175101099Srwatson if (FoundPCH || FoundPTH) { 176101099Srwatson A->claim(); 177101099Srwatson if (UsePCH) 178101099Srwatson CmdArgs.push_back("-include-pch"); 179101099Srwatson else 180101099Srwatson CmdArgs.push_back("-include-pth"); 181101099Srwatson CmdArgs.push_back(Args.MakeArgString(P.str())); 182101099Srwatson continue; 183101099Srwatson } 184101099Srwatson } 185101099Srwatson 186101099Srwatson // Not translated, render as usual. 187101099Srwatson A->claim(); 188101099Srwatson A->render(Args, CmdArgs); 189101099Srwatson } 190101099Srwatson 191101099Srwatson Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 192101099Srwatson Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 193101099Srwatson 194101099Srwatson // Add -Wp, and -Xassembler if using the preprocessor. 195101099Srwatson 196101099Srwatson // FIXME: There is a very unfortunate problem here, some troubled 197101099Srwatson // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 198101099Srwatson // really support that we would have to parse and then translate 199101099Srwatson // those options. :( 200101099Srwatson Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 201101099Srwatson options::OPT_Xpreprocessor); 202101099Srwatson 203101099Srwatson // -I- is a deprecated GCC feature, reject it. 204106212Srwatson if (Arg *A = Args.getLastArg(options::OPT_I_)) 205101099Srwatson D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 206101099Srwatson} 207101099Srwatson 208101099Srwatson/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targetting. 209101099Srwatson// 210101099Srwatson// FIXME: tblgen this. 211101099Srwatsonstatic llvm::StringRef getARMTargetCPU(const ArgList &Args) { 212101099Srwatson // FIXME: Warn on inconsistent use of -mcpu and -march. 213101099Srwatson 214101099Srwatson // If we have -mcpu=, use that. 215101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 216101099Srwatson return A->getValue(Args); 217101099Srwatson 218101099Srwatson // Otherwise, if we have -march= choose the base CPU for that arch. 219101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 220101099Srwatson llvm::StringRef MArch = A->getValue(Args); 221101099Srwatson 222101099Srwatson if (MArch == "armv2" || MArch == "armv2a") 223101099Srwatson return "arm2"; 224101099Srwatson if (MArch == "armv3") 225101099Srwatson return "arm6"; 226101099Srwatson if (MArch == "armv3m") 227101099Srwatson return "arm7m"; 228101099Srwatson if (MArch == "armv4" || MArch == "armv4t") 229101099Srwatson return "arm7tdmi"; 230101099Srwatson if (MArch == "armv5" || MArch == "armv5t") 231101099Srwatson return "arm10tdmi"; 232101099Srwatson if (MArch == "armv5e" || MArch == "armv5te") 233101099Srwatson return "arm1026ejs"; 234101099Srwatson if (MArch == "armv5tej") 235101099Srwatson return "arm926ejs"; 236101099Srwatson if (MArch == "armv6" || MArch == "armv6k") 237101099Srwatson return "arm1136jf-s"; 238101099Srwatson if (MArch == "armv6j") 239101099Srwatson return "arm1136j-s"; 240101099Srwatson if (MArch == "armv6z" || MArch == "armv6zk") 241101099Srwatson return "arm1176jzf-s"; 242101099Srwatson if (MArch == "armv6t2") 243101099Srwatson return "arm1156t2-s"; 244101099Srwatson if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 245101099Srwatson return "cortex-a8"; 246101099Srwatson if (MArch == "armv7r" || MArch == "armv7-r") 247101099Srwatson return "cortex-r4"; 248101099Srwatson if (MArch == "armv7m" || MArch == "armv7-m") 249101099Srwatson return "cortex-m3"; 250101099Srwatson if (MArch == "ep9312") 251101099Srwatson return "ep9312"; 252101099Srwatson if (MArch == "iwmmxt") 253101099Srwatson return "iwmmxt"; 254101099Srwatson if (MArch == "xscale") 255101099Srwatson return "xscale"; 256101099Srwatson } 257101099Srwatson 258101099Srwatson // Otherwise return the most base CPU LLVM supports. 259101099Srwatson return "arm7tdmi"; 260101099Srwatson} 261101099Srwatson 262101099Srwatson/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 263101099Srwatson/// CPU. 264101099Srwatson// 265101099Srwatson// FIXME: This is redundant with -mcpu, why does LLVM use this. 266101099Srwatson// FIXME: tblgen this, or kill it! 267101099Srwatsonstatic const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) { 268101099Srwatson if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" || 269101099Srwatson CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" || 270101099Srwatson CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" || 271101099Srwatson CPU == "arm940t" || CPU == "ep9312") 272101099Srwatson return "v4t"; 273101099Srwatson 274106212Srwatson if (CPU == "arm10tdmi" || CPU == "arm1020t") 275101099Srwatson return "v5"; 276101099Srwatson 277101099Srwatson if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" || 278101099Srwatson CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" || 279101099Srwatson CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" || 280101099Srwatson CPU == "iwmmxt") 281101099Srwatson return "v5e"; 282108376Srwatson 283108376Srwatson if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" || 284108376Srwatson CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore") 285108376Srwatson return "v6"; 286108376Srwatson 287108376Srwatson if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s") 288108376Srwatson return "v6t2"; 289108376Srwatson 290108376Srwatson if (CPU == "cortex-a8" || CPU == "cortex-a9") 291101099Srwatson return "v7"; 292101099Srwatson 293101099Srwatson return ""; 294101099Srwatson} 295101099Srwatson 296101099Srwatson/// getLLVMTriple - Get the LLVM triple to use for a particular toolchain, which 297101099Srwatson/// may depend on command line arguments. 298101099Srwatsonstatic std::string getLLVMTriple(const ToolChain &TC, const ArgList &Args) { 299101099Srwatson switch (TC.getTriple().getArch()) { 300101099Srwatson default: 301112575Srwatson return TC.getTripleString(); 302112575Srwatson 303112575Srwatson case llvm::Triple::arm: 304112575Srwatson case llvm::Triple::thumb: { 305112575Srwatson // FIXME: Factor into subclasses. 306112575Srwatson llvm::Triple Triple = TC.getTriple(); 307112575Srwatson 308112575Srwatson // Thumb2 is the default for V7 on Darwin. 309112575Srwatson // 310112575Srwatson // FIXME: Thumb should just be another -target-feaure, not in the triple. 311112575Srwatson llvm::StringRef Suffix = getLLVMArchSuffixForARM(getARMTargetCPU(Args)); 312112575Srwatson bool ThumbDefault = 313112575Srwatson (Suffix == "v7" && TC.getTriple().getOS() == llvm::Triple::Darwin); 314112575Srwatson std::string ArchName = "arm"; 315112575Srwatson if (Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault)) 316112575Srwatson ArchName = "thumb"; 317101099Srwatson Triple.setArchName(ArchName + Suffix.str()); 318106212Srwatson 319101099Srwatson return Triple.getTriple(); 320101099Srwatson } 321101099Srwatson } 322101099Srwatson} 323101099Srwatson 324101099Srwatson// FIXME: Move to target hook. 325101099Srwatsonstatic bool isSignedCharDefault(const llvm::Triple &Triple) { 326101099Srwatson switch (Triple.getArch()) { 327101099Srwatson default: 328101099Srwatson return true; 329106212Srwatson 330101099Srwatson case llvm::Triple::ppc: 331101099Srwatson case llvm::Triple::ppc64: 332101099Srwatson if (Triple.getOS() == llvm::Triple::Darwin) 333101099Srwatson return true; 334101099Srwatson return false; 335101099Srwatson 336101099Srwatson case llvm::Triple::systemz: 337101099Srwatson return false; 338101099Srwatson } 339101099Srwatson} 340101099Srwatson 341101099Srwatsonvoid Clang::AddARMTargetArgs(const ArgList &Args, 342101099Srwatson ArgStringList &CmdArgs) const { 343101099Srwatson const Driver &D = getToolChain().getHost().getDriver(); 344101099Srwatson 345101099Srwatson // Select the ABI to use. 346101099Srwatson // 347101099Srwatson // FIXME: Support -meabi. 348101099Srwatson const char *ABIName = 0; 349101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 350101099Srwatson ABIName = A->getValue(Args); 351101099Srwatson } else { 352101099Srwatson // Select the default based on the platform. 353101099Srwatson switch (getToolChain().getTriple().getOS()) { 354101099Srwatson // FIXME: Is this right for non-Darwin and non-Linux? 355101099Srwatson default: 356101099Srwatson ABIName = "aapcs"; 357101099Srwatson break; 358101099Srwatson 359101099Srwatson case llvm::Triple::Darwin: 360101099Srwatson ABIName = "apcs-gnu"; 361101099Srwatson break; 362101099Srwatson 363101099Srwatson case llvm::Triple::Linux: 364101099Srwatson ABIName = "aapcs-linux"; 365101099Srwatson break; 366101099Srwatson } 367101099Srwatson } 368101099Srwatson CmdArgs.push_back("-target-abi"); 369101099Srwatson CmdArgs.push_back(ABIName); 370101099Srwatson 371101099Srwatson // Set the CPU based on -march= and -mcpu=. 372101099Srwatson CmdArgs.push_back(Args.MakeArgString("-mcpu=" + getARMTargetCPU(Args))); 373101099Srwatson 374101099Srwatson // Select the float ABI as determined by -msoft-float, -mhard-float, and 375101099Srwatson // -mfloat-abi=. 376101099Srwatson llvm::StringRef FloatABI; 377101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 378101099Srwatson options::OPT_mhard_float, 379101099Srwatson options::OPT_mfloat_abi_EQ)) { 380101099Srwatson if (A->getOption().matches(options::OPT_msoft_float)) 381101099Srwatson FloatABI = "soft"; 382101099Srwatson else if (A->getOption().matches(options::OPT_mhard_float)) 383101099Srwatson FloatABI = "hard"; 384101099Srwatson else { 385101099Srwatson FloatABI = A->getValue(Args); 386101099Srwatson if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 387101099Srwatson D.Diag(clang::diag::err_drv_invalid_mfloat_abi) 388101099Srwatson << A->getAsString(Args); 389101099Srwatson FloatABI = "soft"; 390101099Srwatson } 391101099Srwatson } 392101099Srwatson } 393101099Srwatson 394101099Srwatson // If unspecified, choose the default based on the platform. 395101099Srwatson if (FloatABI.empty()) { 396101099Srwatson // FIXME: This is wrong for non-Darwin, we don't have a mechanism yet for 397101099Srwatson // distinguishing things like linux-eabi vs linux-elf. 398101099Srwatson switch (getToolChain().getTriple().getOS()) { 399101099Srwatson case llvm::Triple::Darwin: { 400101099Srwatson // Darwin defaults to "softfp" for v6 and v7. 401101099Srwatson // 402101099Srwatson // FIXME: Factor out an ARM class so we can cache the arch somewhere. 403101099Srwatson llvm::StringRef ArchName = getLLVMArchSuffixForARM(getARMTargetCPU(Args)); 404101099Srwatson if (ArchName.startswith("v6") || ArchName.startswith("v7")) 405101099Srwatson FloatABI = "softfp"; 406101099Srwatson else 407101099Srwatson FloatABI = "soft"; 408101099Srwatson break; 409101099Srwatson } 410101099Srwatson 411101099Srwatson default: 412101099Srwatson // Assume "soft", but warn the user we are guessing. 413101099Srwatson FloatABI = "soft"; 414101099Srwatson D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 415117247Srwatson break; 416101099Srwatson } 417101099Srwatson } 418101099Srwatson 419101099Srwatson if (FloatABI == "soft") { 420101099Srwatson // Floating point operations and argument passing are soft. 421101099Srwatson // 422106648Srwatson // FIXME: This changes CPP defines, we need -target-soft-float. 423106648Srwatson CmdArgs.push_back("-soft-float"); 424101099Srwatson CmdArgs.push_back("-float-abi=soft"); 425101099Srwatson } else if (FloatABI == "softfp") { 426101099Srwatson // Floating point operations are hard, but argument passing is soft. 427101099Srwatson CmdArgs.push_back("-float-abi=soft"); 428101099Srwatson } else { 429101099Srwatson // Floating point operations and argument passing are hard. 430101099Srwatson assert(FloatABI == "hard" && "Invalid float abi!"); 431101099Srwatson CmdArgs.push_back("-float-abi=hard"); 432101099Srwatson } 433101099Srwatson} 434101099Srwatson 435101099Srwatsonvoid Clang::AddX86TargetArgs(const ArgList &Args, 436101099Srwatson ArgStringList &CmdArgs) const { 437101099Srwatson if (!Args.hasFlag(options::OPT_mred_zone, 438101099Srwatson options::OPT_mno_red_zone, 439101099Srwatson true) || 440101099Srwatson Args.hasArg(options::OPT_mkernel) || 441101099Srwatson Args.hasArg(options::OPT_fapple_kext)) 442101099Srwatson CmdArgs.push_back("--disable-red-zone"); 443101099Srwatson 444101099Srwatson if (Args.hasFlag(options::OPT_msoft_float, 445101099Srwatson options::OPT_mno_soft_float, 446101099Srwatson false)) 447101099Srwatson CmdArgs.push_back("--no-implicit-float"); 448101099Srwatson 449101099Srwatson const char *CPUName = 0; 450101099Srwatson if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 451101099Srwatson if (llvm::StringRef(A->getValue(Args)) == "native") { 452101099Srwatson // FIXME: Reject attempts to use -march=native unless the target matches 453101099Srwatson // the host. 454101099Srwatson // 455101099Srwatson // FIXME: We should also incorporate the detected target features for use 456101099Srwatson // with -native. 457101099Srwatson std::string CPU = llvm::sys::getHostCPUName(); 458101099Srwatson if (!CPU.empty()) 459101099Srwatson CPUName = Args.MakeArgString(CPU); 460101099Srwatson } else 461101099Srwatson CPUName = A->getValue(Args); 462101099Srwatson } 463101099Srwatson 464101099Srwatson // Select the default CPU if none was given (or detection failed). 465101099Srwatson if (!CPUName) { 466101099Srwatson // FIXME: Need target hooks. 467101099Srwatson if (memcmp(getToolChain().getOS().c_str(), "darwin", 6) == 0) { 468101099Srwatson if (getToolChain().getArchName() == "x86_64") 469101099Srwatson CPUName = "core2"; 470101099Srwatson else if (getToolChain().getArchName() == "i386") 471104530Srwatson CPUName = "yonah"; 472104530Srwatson } else { 473104530Srwatson if (getToolChain().getArchName() == "x86_64") 474104530Srwatson CPUName = "x86-64"; 475104530Srwatson else if (getToolChain().getArchName() == "i386") 476104530Srwatson CPUName = "pentium4"; 477104530Srwatson } 478104530Srwatson } 479104530Srwatson 480104530Srwatson if (CPUName) { 481104530Srwatson CmdArgs.push_back("--mcpu"); 482104530Srwatson CmdArgs.push_back(CPUName); 483104530Srwatson } 484104530Srwatson 485106214Srwatson // FIXME: Use iterator. 486106214Srwatson for (ArgList::const_iterator 487104530Srwatson it = Args.begin(), ie = Args.end(); it != ie; ++it) { 488104530Srwatson const Arg *A = *it; 489104530Srwatson if (A->getOption().matches(options::OPT_m_x86_Features_Group)) { 490104530Srwatson llvm::StringRef Name = A->getOption().getName(); 491104530Srwatson 492104530Srwatson // Skip over "-m". 493104530Srwatson assert(Name.startswith("-m") && "Invalid feature name."); 494104530Srwatson Name = Name.substr(2); 495104530Srwatson 496104530Srwatson bool IsNegative = Name.startswith("no-"); 497104530Srwatson if (IsNegative) 498101099Srwatson Name = Name.substr(3); 499101099Srwatson 500101099Srwatson A->claim(); 501101099Srwatson CmdArgs.push_back("-target-feature"); 502101099Srwatson CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 503117247Srwatson } 504101099Srwatson } 505101099Srwatson} 506117247Srwatson 507101099Srwatsonstatic bool needsExceptions(const ArgList &Args, types::ID InputType, 508101099Srwatson const llvm::Triple &Triple) { 509101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 510101099Srwatson options::OPT_fno_exceptions)) { 511101099Srwatson if (A->getOption().matches(options::OPT_fexceptions)) 512101099Srwatson return true; 513101099Srwatson else 514101099Srwatson return false; 515106212Srwatson } 516101099Srwatson switch (InputType) { 517101099Srwatson case types::TY_CXX: case types::TY_CXXHeader: 518101099Srwatson case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 519101099Srwatson case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 520101099Srwatson case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 521101099Srwatson return true; 522101099Srwatson 523101099Srwatson case types::TY_ObjC: case types::TY_ObjCHeader: 524101099Srwatson case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 525101099Srwatson if (Args.hasArg(options::OPT_fobjc_nonfragile_abi)) 526101099Srwatson return true; 527101099Srwatson if (Triple.getOS() != llvm::Triple::Darwin) 528101099Srwatson return false; 529101099Srwatson return (Triple.getDarwinMajorNumber() >= 9 && 530101099Srwatson Triple.getArch() == llvm::Triple::x86_64); 531101099Srwatson 532101099Srwatson default: 533101099Srwatson return false; 534101099Srwatson } 535101099Srwatson} 536101099Srwatson 537101099Srwatson/// getEffectiveClangTriple - Get the "effective" target triple, which is the 538101099Srwatson/// triple for the target but with the OS version potentially modified for 539101099Srwatson/// Darwin's -mmacosx-version-min. 540101099Srwatsonstatic std::string getEffectiveClangTriple(const Driver &D, 541101099Srwatson const ToolChain &TC, 542101099Srwatson const ArgList &Args) { 543101099Srwatson llvm::Triple Triple(getLLVMTriple(TC, Args)); 544101099Srwatson 545101099Srwatson if (Triple.getOS() != llvm::Triple::Darwin) { 546101099Srwatson // Diagnose use of -mmacosx-version-min and -miphoneos-version-min on 547101099Srwatson // non-Darwin. 548101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ, 549101099Srwatson options::OPT_miphoneos_version_min_EQ)) 550101099Srwatson D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 551101099Srwatson return Triple.getTriple(); 552101099Srwatson } 553101099Srwatson 554101099Srwatson // If -mmacosx-version-min=10.3.9 is specified, change the effective triple 555101099Srwatson // from being something like powerpc-apple-darwin9 to powerpc-apple-darwin7. 556101099Srwatson if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) { 557101099Srwatson unsigned Major, Minor, Micro; 558101099Srwatson bool HadExtra; 559101099Srwatson if (!Driver::GetReleaseVersion(A->getValue(Args), Major, Minor, Micro, 560101099Srwatson HadExtra) || HadExtra || 561101099Srwatson Major != 10) 562101099Srwatson D.Diag(clang::diag::err_drv_invalid_version_number) 563101099Srwatson << A->getAsString(Args); 564101099Srwatson 565101099Srwatson // Mangle the MacOS version min number into the Darwin number: e.g. 10.3.9 566101099Srwatson // is darwin7.9. 567101099Srwatson llvm::SmallString<16> Str; 568101099Srwatson llvm::raw_svector_ostream(Str) << "darwin" << Minor + 4 << "." << Micro; 569101099Srwatson Triple.setOSName(Str.str()); 570101099Srwatson } else if (Arg *A = Args.getLastArg(options::OPT_miphoneos_version_min_EQ)) { 571101099Srwatson unsigned Major, Minor, Micro; 572101099Srwatson bool HadExtra; 573101099Srwatson if (!Driver::GetReleaseVersion(A->getValue(Args), Major, Minor, Micro, 574101099Srwatson HadExtra) || HadExtra) 575101099Srwatson D.Diag(clang::diag::err_drv_invalid_version_number) 576101099Srwatson << A->getAsString(Args); 577101099Srwatson 578101099Srwatson // Mangle the iPhoneOS version number into the Darwin number: e.g. 2.0 is 2 579101099Srwatson // -> 9.2.0. 580101099Srwatson llvm::SmallString<16> Str; 581101099Srwatson llvm::raw_svector_ostream(Str) << "darwin9." << Major << "." << Minor; 582101099Srwatson Triple.setOSName(Str.str()); 583101099Srwatson } 584101099Srwatson 585101099Srwatson return Triple.getTriple(); 586101099Srwatson} 587101099Srwatson 588101099Srwatsonvoid Clang::ConstructJob(Compilation &C, const JobAction &JA, 589101099Srwatson Job &Dest, 590101099Srwatson const InputInfo &Output, 591101099Srwatson const InputInfoList &Inputs, 592101099Srwatson const ArgList &Args, 593101099Srwatson const char *LinkingOutput) const { 594101099Srwatson const Driver &D = getToolChain().getHost().getDriver(); 595101099Srwatson ArgStringList CmdArgs; 596101099Srwatson 597101099Srwatson assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 598101099Srwatson 599101099Srwatson // Add the "effective" target triple. 600101099Srwatson CmdArgs.push_back("-triple"); 601101099Srwatson std::string TripleStr = getEffectiveClangTriple(D, getToolChain(), Args); 602101099Srwatson CmdArgs.push_back(Args.MakeArgString(TripleStr)); 603101099Srwatson 604101099Srwatson // Select the appropriate action. 605101099Srwatson if (isa<AnalyzeJobAction>(JA)) { 606101099Srwatson assert(JA.getType() == types::TY_Plist && "Invalid output type."); 607101099Srwatson CmdArgs.push_back("-analyze"); 608101099Srwatson } else if (isa<PreprocessJobAction>(JA)) { 609101099Srwatson if (Output.getType() == types::TY_Dependencies) 610101099Srwatson CmdArgs.push_back("-Eonly"); 611101099Srwatson else 612101099Srwatson CmdArgs.push_back("-E"); 613101099Srwatson } else if (isa<PrecompileJobAction>(JA)) { 614101099Srwatson // Use PCH if the user requested it, except for C++ (for now). 615101099Srwatson bool UsePCH = D.CCCUsePCH; 616101099Srwatson if (types::isCXX(Inputs[0].getType())) 617101099Srwatson UsePCH = false; 618101099Srwatson 619101099Srwatson if (UsePCH) 620101099Srwatson CmdArgs.push_back("-emit-pch"); 621101099Srwatson else 622101099Srwatson CmdArgs.push_back("-emit-pth"); 623101099Srwatson } else { 624101099Srwatson assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 625101099Srwatson 626101099Srwatson if (JA.getType() == types::TY_Nothing) { 627101099Srwatson CmdArgs.push_back("-fsyntax-only"); 628101099Srwatson } else if (JA.getType() == types::TY_LLVMAsm) { 629101099Srwatson CmdArgs.push_back("-emit-llvm"); 630101099Srwatson } else if (JA.getType() == types::TY_LLVMBC) { 631101099Srwatson CmdArgs.push_back("-emit-llvm-bc"); 632101099Srwatson } else if (JA.getType() == types::TY_PP_Asm) { 633101099Srwatson CmdArgs.push_back("-S"); 634101099Srwatson } else if (JA.getType() == types::TY_AST) { 635101099Srwatson CmdArgs.push_back("-emit-pch"); 636101099Srwatson } 637101099Srwatson } 638101099Srwatson 639101099Srwatson // The make clang go fast button. 640101099Srwatson CmdArgs.push_back("-disable-free"); 641101099Srwatson 642101099Srwatson // Set the main file name, so that debug info works even with 643101099Srwatson // -save-temps. 644101099Srwatson CmdArgs.push_back("-main-file-name"); 645101099Srwatson CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 646101099Srwatson 647101099Srwatson // Some flags which affect the language (via preprocessor 648101099Srwatson // defines). See darwin::CC1::AddCPPArgs. 649101099Srwatson if (Args.hasArg(options::OPT_static)) 650101099Srwatson CmdArgs.push_back("-static-define"); 651101099Srwatson 652101099Srwatson if (isa<AnalyzeJobAction>(JA)) { 653101099Srwatson // Enable region store model by default. 654101099Srwatson CmdArgs.push_back("-analyzer-store=region"); 655101099Srwatson 656101099Srwatson // Add default argument set. 657101099Srwatson if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 658101099Srwatson CmdArgs.push_back("-warn-dead-stores"); 659101099Srwatson CmdArgs.push_back("-warn-security-syntactic"); 660101099Srwatson CmdArgs.push_back("-checker-cfref"); 661101099Srwatson CmdArgs.push_back("-analyzer-eagerly-assume"); 662101099Srwatson CmdArgs.push_back("-warn-objc-methodsigs"); 663101099Srwatson // Do not enable the missing -dealloc check. 664101099Srwatson // '-warn-objc-missing-dealloc', 665101099Srwatson CmdArgs.push_back("-warn-objc-unused-ivars"); 666101099Srwatson } 667101099Srwatson 668101099Srwatson // Set the output format. The default is plist, for (lame) historical 669101099Srwatson // reasons. 670101099Srwatson CmdArgs.push_back("-analyzer-output"); 671101099Srwatson if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 672101099Srwatson CmdArgs.push_back(A->getValue(Args)); 673101099Srwatson else 674101099Srwatson CmdArgs.push_back("plist"); 675101099Srwatson 676101099Srwatson // Add -Xanalyzer arguments when running as analyzer. 677101099Srwatson Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 678101099Srwatson } 679101099Srwatson 680101099Srwatson CheckCodeGenerationOptions(D, Args); 681101099Srwatson 682101099Srwatson // Perform argument translation for LLVM backend. This 683101099Srwatson // takes some care in reconciling with llvm-gcc. The 684101099Srwatson // issue is that llvm-gcc translates these options based on 685101099Srwatson // the values in cc1, whereas we are processing based on 686101099Srwatson // the driver arguments. 687101099Srwatson 688101099Srwatson // This comes from the default translation the driver + cc1 689101099Srwatson // would do to enable flag_pic. 690101099Srwatson // 691101099Srwatson // FIXME: Centralize this code. 692101099Srwatson bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 693101099Srwatson Args.hasArg(options::OPT_fpic) || 694101099Srwatson Args.hasArg(options::OPT_fPIE) || 695101099Srwatson Args.hasArg(options::OPT_fpie)); 696101099Srwatson bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 697101099Srwatson Args.hasArg(options::OPT_static)); 698101099Srwatson const char *Model = getToolChain().GetForcedPicModel(); 699101099Srwatson if (!Model) { 700101099Srwatson if (Args.hasArg(options::OPT_mdynamic_no_pic)) 701101099Srwatson Model = "dynamic-no-pic"; 702101099Srwatson else if (PICDisabled) 703101099Srwatson Model = "static"; 704101099Srwatson else if (PICEnabled) 705101099Srwatson Model = "pic"; 706101099Srwatson else 707101099Srwatson Model = getToolChain().GetDefaultRelocationModel(); 708101099Srwatson } 709101099Srwatson CmdArgs.push_back("--relocation-model"); 710101099Srwatson CmdArgs.push_back(Model); 711101099Srwatson 712101099Srwatson // Infer the __PIC__ value. 713101099Srwatson // 714101099Srwatson // FIXME: This isn't quite right on Darwin, which always sets 715101099Srwatson // __PIC__=2. 716101099Srwatson if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 717101099Srwatson if (Args.hasArg(options::OPT_fPIC)) 718101099Srwatson CmdArgs.push_back("-pic-level=2"); 719101099Srwatson else 720101099Srwatson CmdArgs.push_back("-pic-level=1"); 721101099Srwatson } 722101099Srwatson 723101099Srwatson if (Args.hasArg(options::OPT_ftime_report)) 724101099Srwatson CmdArgs.push_back("--time-passes"); 725101099Srwatson // FIXME: Set --enable-unsafe-fp-math. 726101099Srwatson if (Args.hasFlag(options::OPT_fno_omit_frame_pointer, 727101099Srwatson options::OPT_fomit_frame_pointer)) 728102129Srwatson CmdArgs.push_back("--disable-fp-elim"); 729102129Srwatson if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 730101099Srwatson options::OPT_fno_zero_initialized_in_bss, 731101099Srwatson true)) 732101099Srwatson CmdArgs.push_back("--nozero-initialized-in-bss"); 733101099Srwatson if (Args.hasArg(options::OPT_dA) || Args.hasArg(options::OPT_fverbose_asm)) 734101099Srwatson CmdArgs.push_back("--asm-verbose"); 735101099Srwatson if (Args.hasArg(options::OPT_fdebug_pass_structure)) 736101099Srwatson CmdArgs.push_back("--debug-pass=Structure"); 737102129Srwatson if (Args.hasArg(options::OPT_fdebug_pass_arguments)) 738101099Srwatson CmdArgs.push_back("--debug-pass=Arguments"); 739101099Srwatson if (!Args.hasFlag(options::OPT_fmerge_all_constants, 740102129Srwatson options::OPT_fno_merge_all_constants)) 741102129Srwatson CmdArgs.push_back("--no-merge-all-constants"); 742101099Srwatson 743101099Srwatson // This is a coarse approximation of what llvm-gcc actually does, both 744106217Srwatson // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 745101099Srwatson // complicated ways. 746106217Srwatson bool AsynchronousUnwindTables = 747106217Srwatson Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 748112575Srwatson options::OPT_fno_asynchronous_unwind_tables, 749106217Srwatson getToolChain().IsUnwindTablesDefault() && 750106217Srwatson !Args.hasArg(options::OPT_mkernel)); 751106217Srwatson if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 752106217Srwatson AsynchronousUnwindTables)) 753106217Srwatson CmdArgs.push_back("--unwind-tables=1"); 754106217Srwatson else 755106217Srwatson CmdArgs.push_back("--unwind-tables=0"); 756106217Srwatson 757106217Srwatson // FIXME: Handle -mtune=. 758106217Srwatson (void) Args.hasArg(options::OPT_mtune_EQ); 759106217Srwatson 760106217Srwatson if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 761106217Srwatson CmdArgs.push_back("-code-model"); 762106217Srwatson CmdArgs.push_back(A->getValue(Args)); 763106217Srwatson } 764106217Srwatson 765106217Srwatson // Add target specific cpu and features flags. 766106217Srwatson switch(getToolChain().getTriple().getArch()) { 767106217Srwatson default: 768106217Srwatson break; 769106217Srwatson 770106217Srwatson case llvm::Triple::arm: 771106217Srwatson case llvm::Triple::thumb: 772106217Srwatson AddARMTargetArgs(Args, CmdArgs); 773101099Srwatson break; 774101099Srwatson 775112717Srwatson case llvm::Triple::x86: 776101099Srwatson case llvm::Triple::x86_64: 777 AddX86TargetArgs(Args, CmdArgs); 778 break; 779 } 780 781 if (Args.hasFlag(options::OPT_fmath_errno, 782 options::OPT_fno_math_errno, 783 getToolChain().IsMathErrnoDefault())) 784 CmdArgs.push_back("--fmath-errno=1"); 785 else 786 CmdArgs.push_back("--fmath-errno=0"); 787 788 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 789 CmdArgs.push_back("--limit-float-precision"); 790 CmdArgs.push_back(A->getValue(Args)); 791 } 792 793 Arg *Unsupported; 794 if ((Unsupported = Args.getLastArg(options::OPT_MG)) || 795 (Unsupported = Args.getLastArg(options::OPT_MQ)) || 796 (Unsupported = Args.getLastArg(options::OPT_iframework))) 797 D.Diag(clang::diag::err_drv_clang_unsupported) 798 << Unsupported->getOption().getName(); 799 800 Args.AddAllArgs(CmdArgs, options::OPT_v); 801 Args.AddLastArg(CmdArgs, options::OPT_P); 802 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 803 804 // Special case debug options to only pass -g to clang. This is 805 // wrong. 806 if (Args.hasArg(options::OPT_g_Group)) 807 CmdArgs.push_back("-g"); 808 809 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 810 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 811 812 Args.AddLastArg(CmdArgs, options::OPT_isysroot); 813 814 // Add preprocessing options like -I, -D, etc. if we are using the 815 // preprocessor. 816 // 817 // FIXME: Support -fpreprocessed 818 types::ID InputType = Inputs[0].getType(); 819 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 820 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 821 822 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 823 // others. 824 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 825 if (A->getOption().getId() == options::OPT_O4) 826 CmdArgs.push_back("-O3"); 827 else if (A->getValue(Args)[0] == '\0') 828 CmdArgs.push_back("-O2"); 829 else 830 A->render(Args, CmdArgs); 831 } 832 833 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 834 Args.AddLastArg(CmdArgs, options::OPT_pedantic); 835 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 836 Args.AddLastArg(CmdArgs, options::OPT_w); 837 838 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 839 // (-ansi is equivalent to -std=c89). 840 // 841 // If a std is supplied, only add -trigraphs if it follows the 842 // option. 843 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 844 if (Std->getOption().matches(options::OPT_ansi)) 845 if (types::isCXX(InputType)) 846 CmdArgs.push_back("-std=c++98"); 847 else 848 CmdArgs.push_back("-std=c89"); 849 else 850 Std->render(Args, CmdArgs); 851 852 if (Arg *A = Args.getLastArg(options::OPT_trigraphs)) 853 if (A->getIndex() > Std->getIndex()) 854 A->render(Args, CmdArgs); 855 } else { 856 // Honor -std-default. 857 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 858 "-std=", /*Joined=*/true); 859 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 860 } 861 862 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 863 CmdArgs.push_back("-ftemplate-depth"); 864 CmdArgs.push_back(A->getValue(Args)); 865 } 866 867 if (Args.hasArg(options::OPT__relocatable_pch, true)) 868 CmdArgs.push_back("--relocatable-pch"); 869 870 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 871 CmdArgs.push_back("-fconstant-string-class"); 872 CmdArgs.push_back(A->getValue(Args)); 873 } 874 875 // Pass -fmessage-length=. 876 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 877 A->render(Args, CmdArgs); 878 } else { 879 // If -fmessage-length=N was not specified, determine whether this is a 880 // terminal and, if so, implicitly define -fmessage-length appropriately. 881 unsigned N = llvm::sys::Process::StandardErrColumns(); 882 CmdArgs.push_back("-fmessage-length"); 883 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N))); 884 } 885 886 // Forward -f options which we can pass directly. 887 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 888 Args.AddLastArg(CmdArgs, options::OPT_ffreestanding); 889 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 890 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions); 891 Args.AddLastArg(CmdArgs, options::OPT_fno_caret_diagnostics); 892 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column); 893 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc_only); 894 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc); 895 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 896 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 897 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 898 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 899 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_EQ); 900 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 901 902 Args.AddLastArg(CmdArgs, options::OPT_pthread); 903 904 // -stack-protector=0 is default. 905 unsigned StackProtectorLevel = 0; 906 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 907 options::OPT_fstack_protector_all, 908 options::OPT_fstack_protector)) { 909 if (A->getOption().matches(options::OPT_fstack_protector)) 910 StackProtectorLevel = 1; 911 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 912 StackProtectorLevel = 2; 913 } else 914 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel(); 915 if (StackProtectorLevel) { 916 CmdArgs.push_back("-stack-protector"); 917 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel))); 918 } 919 920 // Forward -f options with positive and negative forms; we translate 921 // these by hand. 922 923 // -fbuiltin is default. 924 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 925 CmdArgs.push_back("-fbuiltin=0"); 926 927 // -fblocks=0 is default. 928 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 929 getToolChain().IsBlocksDefault())) { 930 Args.AddLastArg(CmdArgs, options::OPT_fblock_introspection); 931 CmdArgs.push_back("-fblocks"); 932 } 933 934 if (needsExceptions(Args, InputType, getToolChain().getTriple())) 935 CmdArgs.push_back("-fexceptions"); 936 else 937 CmdArgs.push_back("-fexceptions=0"); 938 939 // -frtti is default. 940 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti)) 941 CmdArgs.push_back("-frtti=0"); 942 943 // -fsigned-char is default. 944 if (!Args.hasFlag(options::OPT_fsigned_char, 945 options::OPT_funsigned_char, 946 isSignedCharDefault(getToolChain().getTriple()))) 947 CmdArgs.push_back("-fsigned-char=0"); 948 949 // -fms-extensions=0 is default. 950 if (Args.hasFlag(options::OPT_fms_extensions, 951 options::OPT_fno_ms_extensions, 952 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 953 CmdArgs.push_back("-fms-extensions"); 954 955 // -fnext-runtime is default. 956 if (!Args.hasFlag(options::OPT_fnext_runtime, 957 options::OPT_fgnu_runtime, 958 getToolChain().getTriple().getOS() == llvm::Triple::Darwin)) 959 CmdArgs.push_back("-fgnu-runtime"); 960 961 // -fobjc-nonfragile-abi=0 is default. 962 if (types::isObjC(InputType)) { 963 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi) || 964 getToolChain().IsObjCNonFragileABIDefault()) 965 CmdArgs.push_back("-fobjc-nonfragile-abi"); 966 } 967 968 // -fshort-wchar default varies depending on platform; only 969 // pass if specified. 970 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) { 971 if (A->getOption().matches(options::OPT_fshort_wchar)) 972 CmdArgs.push_back("-fshort-wchar"); 973 } 974 975 // -fno-pascal-strings is default, only pass non-default. If the tool chain 976 // happened to translate to -mpascal-strings, we want to back translate here. 977 // 978 // FIXME: This is gross; that translation should be pulled from the 979 // tool chain. 980 if (Args.hasFlag(options::OPT_fpascal_strings, 981 options::OPT_fno_pascal_strings, 982 false) || 983 Args.hasFlag(options::OPT_mpascal_strings, 984 options::OPT_mno_pascal_strings, 985 false)) 986 CmdArgs.push_back("-fpascal-strings"); 987 988 // -fcommon is default, only pass non-default. 989 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 990 CmdArgs.push_back("-fno-common"); 991 992 // -fsigned-bitfields is default, and clang doesn't yet support 993 // --funsigned-bitfields. 994 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 995 options::OPT_funsigned_bitfields)) 996 D.Diag(clang::diag::warn_drv_clang_unsupported) 997 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 998 999 // -fdiagnostics-fixit-info is default, only pass non-default. 1000 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 1001 options::OPT_fno_diagnostics_fixit_info)) 1002 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 1003 1004 // Enable -fdiagnostics-show-option by default. 1005 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 1006 options::OPT_fno_diagnostics_show_option)) 1007 CmdArgs.push_back("-fdiagnostics-show-option"); 1008 1009 // Color diagnostics are the default, unless the terminal doesn't support 1010 // them. 1011 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 1012 options::OPT_fno_color_diagnostics) && 1013 llvm::sys::Process::StandardErrHasColors()) 1014 CmdArgs.push_back("-fcolor-diagnostics"); 1015 1016 if (!Args.hasFlag(options::OPT_fshow_source_location, 1017 options::OPT_fno_show_source_location)) 1018 CmdArgs.push_back("-fno-show-source-location"); 1019 1020 // -fdollars-in-identifiers default varies depending on platform and 1021 // language; only pass if specified. 1022 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 1023 options::OPT_fno_dollars_in_identifiers)) { 1024 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 1025 CmdArgs.push_back("-fdollars-in-identifiers=1"); 1026 else 1027 CmdArgs.push_back("-fdollars-in-identifiers=0"); 1028 } 1029 1030 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 1031 // practical purposes. 1032 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 1033 options::OPT_fno_unit_at_a_time)) { 1034 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 1035 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args); 1036 } 1037 1038 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 1039 // 1040 // FIXME: This is disabled until clang-cc supports -fno-builtin-foo. PR4941. 1041#if 0 1042 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1043 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1044 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 1045 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1046 CmdArgs.push_back("-fno-builtin-strcat"); 1047 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1048 CmdArgs.push_back("-fno-builtin-strcpy"); 1049 } 1050#endif 1051 1052 if (Arg *A = Args.getLastArg(options::OPT_traditional, 1053 options::OPT_traditional_cpp)) 1054 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1055 1056 Args.AddLastArg(CmdArgs, options::OPT_dM); 1057 Args.AddLastArg(CmdArgs, options::OPT_dD); 1058 1059 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 1060 Args.AddAllArgValues(CmdArgs, options::OPT_mllvm); 1061 1062 if (Output.getType() == types::TY_Dependencies) { 1063 // Handled with other dependency code. 1064 } else if (Output.isPipe()) { 1065 CmdArgs.push_back("-o"); 1066 CmdArgs.push_back("-"); 1067 } else if (Output.isFilename()) { 1068 CmdArgs.push_back("-o"); 1069 CmdArgs.push_back(Output.getFilename()); 1070 } else { 1071 assert(Output.isNothing() && "Invalid output."); 1072 } 1073 1074 for (InputInfoList::const_iterator 1075 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1076 const InputInfo &II = *it; 1077 CmdArgs.push_back("-x"); 1078 CmdArgs.push_back(types::getTypeName(II.getType())); 1079 if (II.isPipe()) 1080 CmdArgs.push_back("-"); 1081 else if (II.isFilename()) 1082 CmdArgs.push_back(II.getFilename()); 1083 else 1084 II.getInputArg().renderAsInput(Args, CmdArgs); 1085 } 1086 1087 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1088 1089 const char *Exec = 1090 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang-cc")); 1091 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 1092 1093 // Explicitly warn that these options are unsupported, even though 1094 // we are allowing compilation to continue. 1095 // FIXME: Use iterator. 1096 for (ArgList::const_iterator 1097 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1098 const Arg *A = *it; 1099 if (A->getOption().matches(options::OPT_pg)) { 1100 A->claim(); 1101 D.Diag(clang::diag::warn_drv_clang_unsupported) 1102 << A->getAsString(Args); 1103 } 1104 } 1105 1106 // Claim some arguments which clang supports automatically. 1107 1108 // -fpch-preprocess is used with gcc to add a special marker in the 1109 // -output to include the PCH file. Clang's PTH solution is 1110 // -completely transparent, so we do not need to deal with it at 1111 // -all. 1112 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 1113 1114 // Claim some arguments which clang doesn't support, but we don't 1115 // care to warn the user about. 1116 1117 // FIXME: Use iterator. 1118 for (ArgList::const_iterator 1119 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1120 const Arg *A = *it; 1121 if (A->getOption().matches(options::OPT_clang_ignored_f_Group) || 1122 A->getOption().matches(options::OPT_clang_ignored_m_Group)) 1123 A->claim(); 1124 } 1125} 1126 1127void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 1128 Job &Dest, 1129 const InputInfo &Output, 1130 const InputInfoList &Inputs, 1131 const ArgList &Args, 1132 const char *LinkingOutput) const { 1133 const Driver &D = getToolChain().getHost().getDriver(); 1134 ArgStringList CmdArgs; 1135 1136 for (ArgList::const_iterator 1137 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1138 Arg *A = *it; 1139 if (A->getOption().hasForwardToGCC()) { 1140 // It is unfortunate that we have to claim here, as this means 1141 // we will basically never report anything interesting for 1142 // platforms using a generic gcc, even if we are just using gcc 1143 // to get to the assembler. 1144 A->claim(); 1145 A->render(Args, CmdArgs); 1146 } 1147 } 1148 1149 RenderExtraToolArgs(CmdArgs); 1150 1151 // If using a driver driver, force the arch. 1152 const std::string &Arch = getToolChain().getArchName(); 1153 if (getToolChain().getHost().useDriverDriver()) { 1154 CmdArgs.push_back("-arch"); 1155 1156 // FIXME: Remove these special cases. 1157 if (Arch == "powerpc") 1158 CmdArgs.push_back("ppc"); 1159 else if (Arch == "powerpc64") 1160 CmdArgs.push_back("ppc64"); 1161 else 1162 CmdArgs.push_back(Args.MakeArgString(Arch)); 1163 } 1164 1165 // Try to force gcc to match the tool chain we want, if we recognize 1166 // the arch. 1167 // 1168 // FIXME: The triple class should directly provide the information we want 1169 // here. 1170 if (Arch == "i386" || Arch == "powerpc") 1171 CmdArgs.push_back("-m32"); 1172 else if (Arch == "x86_64" || Arch == "powerpc64") 1173 CmdArgs.push_back("-m64"); 1174 1175 if (Output.isPipe()) { 1176 CmdArgs.push_back("-o"); 1177 CmdArgs.push_back("-"); 1178 } else if (Output.isFilename()) { 1179 CmdArgs.push_back("-o"); 1180 CmdArgs.push_back(Output.getFilename()); 1181 } else { 1182 assert(Output.isNothing() && "Unexpected output"); 1183 CmdArgs.push_back("-fsyntax-only"); 1184 } 1185 1186 1187 // Only pass -x if gcc will understand it; otherwise hope gcc 1188 // understands the suffix correctly. The main use case this would go 1189 // wrong in is for linker inputs if they happened to have an odd 1190 // suffix; really the only way to get this to happen is a command 1191 // like '-x foobar a.c' which will treat a.c like a linker input. 1192 // 1193 // FIXME: For the linker case specifically, can we safely convert 1194 // inputs into '-Wl,' options? 1195 for (InputInfoList::const_iterator 1196 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1197 const InputInfo &II = *it; 1198 1199 // Don't try to pass LLVM or AST inputs to a generic gcc. 1200 if (II.getType() == types::TY_LLVMBC) 1201 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1202 << getToolChain().getTripleString(); 1203 else if (II.getType() == types::TY_AST) 1204 D.Diag(clang::diag::err_drv_no_ast_support) 1205 << getToolChain().getTripleString(); 1206 1207 if (types::canTypeBeUserSpecified(II.getType())) { 1208 CmdArgs.push_back("-x"); 1209 CmdArgs.push_back(types::getTypeName(II.getType())); 1210 } 1211 1212 if (II.isPipe()) 1213 CmdArgs.push_back("-"); 1214 else if (II.isFilename()) 1215 CmdArgs.push_back(II.getFilename()); 1216 else 1217 // Don't render as input, we need gcc to do the translations. 1218 II.getInputArg().render(Args, CmdArgs); 1219 } 1220 1221 const char *GCCName = 1222 getToolChain().getHost().getDriver().CCCGenericGCCName.c_str(); 1223 const char *Exec = 1224 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName)); 1225 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 1226} 1227 1228void gcc::Preprocess::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 1229 CmdArgs.push_back("-E"); 1230} 1231 1232void gcc::Precompile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 1233 // The type is good enough. 1234} 1235 1236void gcc::Compile::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 1237 CmdArgs.push_back("-S"); 1238} 1239 1240void gcc::Assemble::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 1241 CmdArgs.push_back("-c"); 1242} 1243 1244void gcc::Link::RenderExtraToolArgs(ArgStringList &CmdArgs) const { 1245 // The types are (hopefully) good enough. 1246} 1247 1248const char *darwin::CC1::getCC1Name(types::ID Type) const { 1249 switch (Type) { 1250 default: 1251 assert(0 && "Unexpected type for Darwin CC1 tool."); 1252 case types::TY_Asm: 1253 case types::TY_C: case types::TY_CHeader: 1254 case types::TY_PP_C: case types::TY_PP_CHeader: 1255 return "cc1"; 1256 case types::TY_ObjC: case types::TY_ObjCHeader: 1257 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 1258 return "cc1obj"; 1259 case types::TY_CXX: case types::TY_CXXHeader: 1260 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 1261 return "cc1plus"; 1262 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 1263 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 1264 return "cc1objplus"; 1265 } 1266} 1267 1268const char *darwin::CC1::getBaseInputName(const ArgList &Args, 1269 const InputInfoList &Inputs) { 1270 llvm::sys::Path P(Inputs[0].getBaseInput()); 1271 return Args.MakeArgString(P.getLast()); 1272} 1273 1274const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 1275 const InputInfoList &Inputs) { 1276 const char *Str = getBaseInputName(Args, Inputs); 1277 1278 if (const char *End = strchr(Str, '.')) 1279 return Args.MakeArgString(std::string(Str, End)); 1280 1281 return Str; 1282} 1283 1284const char * 1285darwin::CC1::getDependencyFileName(const ArgList &Args, 1286 const InputInfoList &Inputs) { 1287 // FIXME: Think about this more. 1288 std::string Res; 1289 1290 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1291 std::string Str(OutputOpt->getValue(Args)); 1292 1293 Res = Str.substr(0, Str.rfind('.')); 1294 } else 1295 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 1296 1297 return Args.MakeArgString(Res + ".d"); 1298} 1299 1300void darwin::CC1::AddCC1Args(const ArgList &Args, 1301 ArgStringList &CmdArgs) const { 1302 const Driver &D = getToolChain().getHost().getDriver(); 1303 1304 CheckCodeGenerationOptions(D, Args); 1305 1306 // Derived from cc1 spec. 1307 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 1308 !Args.hasArg(options::OPT_mdynamic_no_pic)) 1309 CmdArgs.push_back("-fPIC"); 1310 1311 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1312 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1313 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1314 CmdArgs.push_back("-fno-builtin-strcat"); 1315 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1316 CmdArgs.push_back("-fno-builtin-strcpy"); 1317 } 1318 1319 // gcc has some code here to deal with when no -mmacosx-version-min 1320 // and no -miphoneos-version-min is present, but this never happens 1321 // due to tool chain specific argument translation. 1322 1323 if (Args.hasArg(options::OPT_g_Flag) && 1324 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 1325 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 1326} 1327 1328void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1329 const InputInfoList &Inputs, 1330 const ArgStringList &OutputArgs) const { 1331 const Driver &D = getToolChain().getHost().getDriver(); 1332 1333 // Derived from cc1_options spec. 1334 if (Args.hasArg(options::OPT_fast) || 1335 Args.hasArg(options::OPT_fastf) || 1336 Args.hasArg(options::OPT_fastcp)) 1337 CmdArgs.push_back("-O3"); 1338 1339 if (Arg *A = Args.getLastArg(options::OPT_pg)) 1340 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 1341 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1342 << A->getAsString(Args) << "-fomit-frame-pointer"; 1343 1344 AddCC1Args(Args, CmdArgs); 1345 1346 if (!Args.hasArg(options::OPT_Q)) 1347 CmdArgs.push_back("-quiet"); 1348 1349 CmdArgs.push_back("-dumpbase"); 1350 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 1351 1352 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1353 1354 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1355 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 1356 1357 // FIXME: The goal is to use the user provided -o if that is our 1358 // final output, otherwise to drive from the original input 1359 // name. Find a clean way to go about this. 1360 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 1361 Args.hasArg(options::OPT_o)) { 1362 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 1363 CmdArgs.push_back("-auxbase-strip"); 1364 CmdArgs.push_back(OutputOpt->getValue(Args)); 1365 } else { 1366 CmdArgs.push_back("-auxbase"); 1367 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 1368 } 1369 1370 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 1371 1372 Args.AddAllArgs(CmdArgs, options::OPT_O); 1373 // FIXME: -Wall is getting some special treatment. Investigate. 1374 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1375 Args.AddLastArg(CmdArgs, options::OPT_w); 1376 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1377 options::OPT_trigraphs); 1378 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1379 // Honor -std-default. 1380 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1381 "-std=", /*Joined=*/true); 1382 } 1383 1384 if (Args.hasArg(options::OPT_v)) 1385 CmdArgs.push_back("-version"); 1386 if (Args.hasArg(options::OPT_pg)) 1387 CmdArgs.push_back("-p"); 1388 Args.AddLastArg(CmdArgs, options::OPT_p); 1389 1390 // The driver treats -fsyntax-only specially. 1391 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1392 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1393 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 1394 // used to inhibit the default -fno-builtin-str{cat,cpy}. 1395 // 1396 // FIXME: Should we grow a better way to deal with "removing" args? 1397 // 1398 // FIXME: Use iterator. 1399 for (ArgList::const_iterator it = Args.begin(), 1400 ie = Args.end(); it != ie; ++it) { 1401 const Arg *A = *it; 1402 if (A->getOption().matches(options::OPT_f_Group) || 1403 A->getOption().matches(options::OPT_fsyntax_only)) { 1404 if (!A->getOption().matches(options::OPT_fbuiltin_strcat) && 1405 !A->getOption().matches(options::OPT_fbuiltin_strcpy)) { 1406 A->claim(); 1407 A->render(Args, CmdArgs); 1408 } 1409 } 1410 } 1411 } else 1412 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1413 1414 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1415 if (Args.hasArg(options::OPT_Qn)) 1416 CmdArgs.push_back("-fno-ident"); 1417 1418 // FIXME: This isn't correct. 1419 //Args.AddLastArg(CmdArgs, options::OPT__help) 1420 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 1421 1422 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1423 1424 // FIXME: Still don't get what is happening here. Investigate. 1425 Args.AddAllArgs(CmdArgs, options::OPT__param); 1426 1427 if (Args.hasArg(options::OPT_fmudflap) || 1428 Args.hasArg(options::OPT_fmudflapth)) { 1429 CmdArgs.push_back("-fno-builtin"); 1430 CmdArgs.push_back("-fno-merge-constants"); 1431 } 1432 1433 if (Args.hasArg(options::OPT_coverage)) { 1434 CmdArgs.push_back("-fprofile-arcs"); 1435 CmdArgs.push_back("-ftest-coverage"); 1436 } 1437 1438 if (types::isCXX(Inputs[0].getType())) 1439 CmdArgs.push_back("-D__private_extern__=extern"); 1440} 1441 1442void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1443 const InputInfoList &Inputs, 1444 const ArgStringList &OutputArgs) const { 1445 // Derived from cpp_options 1446 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1447 1448 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1449 1450 AddCC1Args(Args, CmdArgs); 1451 1452 // NOTE: The code below has some commonality with cpp_options, but 1453 // in classic gcc style ends up sending things in different 1454 // orders. This may be a good merge candidate once we drop pedantic 1455 // compatibility. 1456 1457 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1458 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1459 options::OPT_trigraphs); 1460 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1461 // Honor -std-default. 1462 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1463 "-std=", /*Joined=*/true); 1464 } 1465 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1466 Args.AddLastArg(CmdArgs, options::OPT_w); 1467 1468 // The driver treats -fsyntax-only specially. 1469 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1470 1471 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 1472 !Args.hasArg(options::OPT_fno_working_directory)) 1473 CmdArgs.push_back("-fworking-directory"); 1474 1475 Args.AddAllArgs(CmdArgs, options::OPT_O); 1476 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1477 if (Args.hasArg(options::OPT_save_temps)) 1478 CmdArgs.push_back("-fpch-preprocess"); 1479} 1480 1481void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 1482 ArgStringList &CmdArgs, 1483 const InputInfoList &Inputs) const { 1484 const Driver &D = getToolChain().getHost().getDriver(); 1485 1486 CheckPreprocessingOptions(D, Args); 1487 1488 // Derived from cpp_unique_options. 1489 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 1490 Args.AddLastArg(CmdArgs, options::OPT_C); 1491 Args.AddLastArg(CmdArgs, options::OPT_CC); 1492 if (!Args.hasArg(options::OPT_Q)) 1493 CmdArgs.push_back("-quiet"); 1494 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 1495 Args.AddLastArg(CmdArgs, options::OPT_v); 1496 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 1497 Args.AddLastArg(CmdArgs, options::OPT_P); 1498 1499 // FIXME: Handle %I properly. 1500 if (getToolChain().getArchName() == "x86_64") { 1501 CmdArgs.push_back("-imultilib"); 1502 CmdArgs.push_back("x86_64"); 1503 } 1504 1505 if (Args.hasArg(options::OPT_MD)) { 1506 CmdArgs.push_back("-MD"); 1507 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1508 } 1509 1510 if (Args.hasArg(options::OPT_MMD)) { 1511 CmdArgs.push_back("-MMD"); 1512 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1513 } 1514 1515 Args.AddLastArg(CmdArgs, options::OPT_M); 1516 Args.AddLastArg(CmdArgs, options::OPT_MM); 1517 Args.AddAllArgs(CmdArgs, options::OPT_MF); 1518 Args.AddLastArg(CmdArgs, options::OPT_MG); 1519 Args.AddLastArg(CmdArgs, options::OPT_MP); 1520 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 1521 Args.AddAllArgs(CmdArgs, options::OPT_MT); 1522 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 1523 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 1524 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1525 CmdArgs.push_back("-MQ"); 1526 CmdArgs.push_back(OutputOpt->getValue(Args)); 1527 } 1528 } 1529 1530 Args.AddLastArg(CmdArgs, options::OPT_remap); 1531 if (Args.hasArg(options::OPT_g3)) 1532 CmdArgs.push_back("-dD"); 1533 Args.AddLastArg(CmdArgs, options::OPT_H); 1534 1535 AddCPPArgs(Args, CmdArgs); 1536 1537 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 1538 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 1539 1540 for (InputInfoList::const_iterator 1541 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1542 const InputInfo &II = *it; 1543 1544 if (II.isPipe()) 1545 CmdArgs.push_back("-"); 1546 else 1547 CmdArgs.push_back(II.getFilename()); 1548 } 1549 1550 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1551 options::OPT_Xpreprocessor); 1552 1553 if (Args.hasArg(options::OPT_fmudflap)) { 1554 CmdArgs.push_back("-D_MUDFLAP"); 1555 CmdArgs.push_back("-include"); 1556 CmdArgs.push_back("mf-runtime.h"); 1557 } 1558 1559 if (Args.hasArg(options::OPT_fmudflapth)) { 1560 CmdArgs.push_back("-D_MUDFLAP"); 1561 CmdArgs.push_back("-D_MUDFLAPTH"); 1562 CmdArgs.push_back("-include"); 1563 CmdArgs.push_back("mf-runtime.h"); 1564 } 1565} 1566 1567void darwin::CC1::AddCPPArgs(const ArgList &Args, 1568 ArgStringList &CmdArgs) const { 1569 // Derived from cpp spec. 1570 1571 if (Args.hasArg(options::OPT_static)) { 1572 // The gcc spec is broken here, it refers to dynamic but 1573 // that has been translated. Start by being bug compatible. 1574 1575 // if (!Args.hasArg(arglist.parser.dynamicOption)) 1576 CmdArgs.push_back("-D__STATIC__"); 1577 } else 1578 CmdArgs.push_back("-D__DYNAMIC__"); 1579 1580 if (Args.hasArg(options::OPT_pthread)) 1581 CmdArgs.push_back("-D_REENTRANT"); 1582} 1583 1584void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 1585 Job &Dest, const InputInfo &Output, 1586 const InputInfoList &Inputs, 1587 const ArgList &Args, 1588 const char *LinkingOutput) const { 1589 ArgStringList CmdArgs; 1590 1591 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1592 1593 CmdArgs.push_back("-E"); 1594 1595 if (Args.hasArg(options::OPT_traditional) || 1596 Args.hasArg(options::OPT_traditional_cpp)) 1597 CmdArgs.push_back("-traditional-cpp"); 1598 1599 ArgStringList OutputArgs; 1600 if (Output.isFilename()) { 1601 OutputArgs.push_back("-o"); 1602 OutputArgs.push_back(Output.getFilename()); 1603 } else { 1604 assert(Output.isPipe() && "Unexpected CC1 output."); 1605 } 1606 1607 if (Args.hasArg(options::OPT_E)) { 1608 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1609 } else { 1610 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1611 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1612 } 1613 1614 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1615 1616 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1617 const char *Exec = 1618 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 1619 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 1620} 1621 1622void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 1623 Job &Dest, const InputInfo &Output, 1624 const InputInfoList &Inputs, 1625 const ArgList &Args, 1626 const char *LinkingOutput) const { 1627 const Driver &D = getToolChain().getHost().getDriver(); 1628 ArgStringList CmdArgs; 1629 1630 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1631 1632 types::ID InputType = Inputs[0].getType(); 1633 const Arg *A; 1634 if ((A = Args.getLastArg(options::OPT_traditional))) 1635 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1636 << A->getAsString(Args) << "-E"; 1637 1638 if (Output.getType() == types::TY_LLVMAsm) 1639 CmdArgs.push_back("-emit-llvm"); 1640 else if (Output.getType() == types::TY_LLVMBC) 1641 CmdArgs.push_back("-emit-llvm-bc"); 1642 else if (Output.getType() == types::TY_AST) 1643 D.Diag(clang::diag::err_drv_no_ast_support) 1644 << getToolChain().getTripleString(); 1645 1646 ArgStringList OutputArgs; 1647 if (Output.getType() != types::TY_PCH) { 1648 OutputArgs.push_back("-o"); 1649 if (Output.isPipe()) 1650 OutputArgs.push_back("-"); 1651 else if (Output.isNothing()) 1652 OutputArgs.push_back("/dev/null"); 1653 else 1654 OutputArgs.push_back(Output.getFilename()); 1655 } 1656 1657 // There is no need for this level of compatibility, but it makes 1658 // diffing easier. 1659 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 1660 Args.hasArg(options::OPT_S)); 1661 1662 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 1663 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1664 if (OutputArgsEarly) { 1665 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1666 } else { 1667 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1668 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1669 } 1670 } else { 1671 CmdArgs.push_back("-fpreprocessed"); 1672 1673 for (InputInfoList::const_iterator 1674 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1675 const InputInfo &II = *it; 1676 1677 // Reject AST inputs. 1678 if (II.getType() == types::TY_AST) { 1679 D.Diag(clang::diag::err_drv_no_ast_support) 1680 << getToolChain().getTripleString(); 1681 return; 1682 } 1683 1684 if (II.isPipe()) 1685 CmdArgs.push_back("-"); 1686 else 1687 CmdArgs.push_back(II.getFilename()); 1688 } 1689 1690 if (OutputArgsEarly) { 1691 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1692 } else { 1693 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1694 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1695 } 1696 } 1697 1698 if (Output.getType() == types::TY_PCH) { 1699 assert(Output.isFilename() && "Invalid PCH output."); 1700 1701 CmdArgs.push_back("-o"); 1702 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 1703 // to be a good reason. 1704 CmdArgs.push_back("/dev/null"); 1705 1706 CmdArgs.push_back("--output-pch="); 1707 CmdArgs.push_back(Output.getFilename()); 1708 } 1709 1710 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1711 const char *Exec = 1712 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 1713 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 1714} 1715 1716void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1717 Job &Dest, const InputInfo &Output, 1718 const InputInfoList &Inputs, 1719 const ArgList &Args, 1720 const char *LinkingOutput) const { 1721 ArgStringList CmdArgs; 1722 1723 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1724 const InputInfo &Input = Inputs[0]; 1725 1726 // Bit of a hack, this is only used for original inputs. 1727 // 1728 // FIXME: This is broken for preprocessed .s inputs. 1729 if (Input.isFilename() && 1730 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 1731 if (Args.hasArg(options::OPT_gstabs)) 1732 CmdArgs.push_back("--gstabs"); 1733 else if (Args.hasArg(options::OPT_g_Group)) 1734 CmdArgs.push_back("--gdwarf2"); 1735 } 1736 1737 // Derived from asm spec. 1738 AddDarwinArch(Args, CmdArgs); 1739 1740 if (!getDarwinToolChain().isIPhoneOS() || 1741 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 1742 CmdArgs.push_back("-force_cpusubtype_ALL"); 1743 1744 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 1745 (Args.hasArg(options::OPT_mkernel) || 1746 Args.hasArg(options::OPT_static) || 1747 Args.hasArg(options::OPT_fapple_kext))) 1748 CmdArgs.push_back("-static"); 1749 1750 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1751 options::OPT_Xassembler); 1752 1753 assert(Output.isFilename() && "Unexpected lipo output."); 1754 CmdArgs.push_back("-o"); 1755 CmdArgs.push_back(Output.getFilename()); 1756 1757 if (Input.isPipe()) { 1758 CmdArgs.push_back("-"); 1759 } else { 1760 assert(Input.isFilename() && "Invalid input."); 1761 CmdArgs.push_back(Input.getFilename()); 1762 } 1763 1764 // asm_final spec is empty. 1765 1766 const char *Exec = 1767 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 1768 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 1769} 1770 1771/// Helper routine for seeing if we should use dsymutil; this is a 1772/// gcc compatible hack, we should remove it and use the input 1773/// type information. 1774static bool isSourceSuffix(const char *Str) { 1775 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm', 1776 // 'mm'. 1777 return llvm::StringSwitch<bool>(Str) 1778 .Case("C", true) 1779 .Case("c", true) 1780 .Case("m", true) 1781 .Case("cc", true) 1782 .Case("cp", true) 1783 .Case("mm", true) 1784 .Case("CPP", true) 1785 .Case("c++", true) 1786 .Case("cpp", true) 1787 .Case("cxx", true) 1788 .Default(false); 1789} 1790 1791// FIXME: Can we tablegen this? 1792static const char *GetArmArchForMArch(llvm::StringRef Value) { 1793 if (Value == "armv6k") 1794 return "armv6"; 1795 1796 if (Value == "armv5tej") 1797 return "armv5"; 1798 1799 if (Value == "xscale") 1800 return "xscale"; 1801 1802 if (Value == "armv4t") 1803 return "armv4t"; 1804 1805 if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" || 1806 Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" || 1807 Value == "armv7m") 1808 return "armv7"; 1809 1810 return 0; 1811} 1812 1813// FIXME: Can we tablegen this? 1814static const char *GetArmArchForMCpu(llvm::StringRef Value) { 1815 if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" || 1816 Value == "arm946e-s" || Value == "arm966e-s" || 1817 Value == "arm968e-s" || Value == "arm10e" || 1818 Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" || 1819 Value == "arm1026ej-s") 1820 return "armv5"; 1821 1822 if (Value == "xscale") 1823 return "xscale"; 1824 1825 if (Value == "arm1136j-s" || Value == "arm1136jf-s" || 1826 Value == "arm1176jz-s" || Value == "arm1176jzf-s") 1827 return "armv6"; 1828 1829 if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3") 1830 return "armv7"; 1831 1832 return 0; 1833} 1834 1835void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 1836 ArgStringList &CmdArgs) const { 1837 // Derived from darwin_arch spec. 1838 CmdArgs.push_back("-arch"); 1839 1840 switch (getToolChain().getTriple().getArch()) { 1841 default: 1842 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName())); 1843 break; 1844 1845 case llvm::Triple::arm: { 1846 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 1847 if (const char *Arch = GetArmArchForMArch(A->getValue(Args))) { 1848 CmdArgs.push_back(Arch); 1849 return; 1850 } 1851 } 1852 1853 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 1854 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args))) { 1855 CmdArgs.push_back(Arch); 1856 return; 1857 } 1858 } 1859 1860 CmdArgs.push_back("arm"); 1861 CmdArgs.push_back("-force_cpusubtype_ALL"); 1862 return; 1863 } 1864 } 1865} 1866 1867void darwin::DarwinTool::AddDarwinSubArch(const ArgList &Args, 1868 ArgStringList &CmdArgs) const { 1869 // Derived from darwin_subarch spec, not sure what the distinction 1870 // exists for but at least for this chain it is the same. 1871 AddDarwinArch(Args, CmdArgs); 1872} 1873 1874void darwin::Link::AddLinkArgs(const ArgList &Args, 1875 ArgStringList &CmdArgs) const { 1876 const Driver &D = getToolChain().getHost().getDriver(); 1877 1878 // Derived from the "link" spec. 1879 Args.AddAllArgs(CmdArgs, options::OPT_static); 1880 if (!Args.hasArg(options::OPT_static)) 1881 CmdArgs.push_back("-dynamic"); 1882 if (Args.hasArg(options::OPT_fgnu_runtime)) { 1883 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 1884 // here. How do we wish to handle such things? 1885 } 1886 1887 if (!Args.hasArg(options::OPT_dynamiclib)) { 1888 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1889 AddDarwinArch(Args, CmdArgs); 1890 CmdArgs.push_back("-force_cpusubtype_ALL"); 1891 } else 1892 AddDarwinSubArch(Args, CmdArgs); 1893 1894 Args.AddLastArg(CmdArgs, options::OPT_bundle); 1895 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 1896 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 1897 1898 Arg *A; 1899 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 1900 (A = Args.getLastArg(options::OPT_current__version)) || 1901 (A = Args.getLastArg(options::OPT_install__name))) 1902 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1903 << A->getAsString(Args) << "-dynamiclib"; 1904 1905 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 1906 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 1907 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 1908 } else { 1909 CmdArgs.push_back("-dylib"); 1910 1911 Arg *A; 1912 if ((A = Args.getLastArg(options::OPT_bundle)) || 1913 (A = Args.getLastArg(options::OPT_bundle__loader)) || 1914 (A = Args.getLastArg(options::OPT_client__name)) || 1915 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 1916 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 1917 (A = Args.getLastArg(options::OPT_private__bundle))) 1918 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1919 << A->getAsString(Args) << "-dynamiclib"; 1920 1921 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 1922 "-dylib_compatibility_version"); 1923 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 1924 "-dylib_current_version"); 1925 1926 if (Args.hasArg(options::OPT_force__cpusubtype__ALL)) { 1927 AddDarwinArch(Args, CmdArgs); 1928 // NOTE: We don't add -force_cpusubtype_ALL on this path. Ok. 1929 } else 1930 AddDarwinSubArch(Args, CmdArgs); 1931 1932 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 1933 "-dylib_install_name"); 1934 } 1935 1936 Args.AddLastArg(CmdArgs, options::OPT_all__load); 1937 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 1938 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 1939 if (getDarwinToolChain().isIPhoneOS()) 1940 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 1941 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 1942 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 1943 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 1944 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 1945 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 1946 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 1947 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 1948 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 1949 Args.AddAllArgs(CmdArgs, options::OPT_init); 1950 1951 if (!Args.hasArg(options::OPT_mmacosx_version_min_EQ) && 1952 !Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 1953 // Add default version min. 1954 if (!getDarwinToolChain().isIPhoneOS()) { 1955 CmdArgs.push_back("-macosx_version_min"); 1956 CmdArgs.push_back(getDarwinToolChain().getMacosxVersionStr()); 1957 } else { 1958 CmdArgs.push_back("-iphoneos_version_min"); 1959 CmdArgs.push_back(getDarwinToolChain().getIPhoneOSVersionStr()); 1960 } 1961 } 1962 1963 // Adding all arguments doesn't make sense here but this is what 1964 // gcc does. 1965 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 1966 "-macosx_version_min"); 1967 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 1968 "-iphoneos_version_min"); 1969 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 1970 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 1971 Args.AddLastArg(CmdArgs, options::OPT_single__module); 1972 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 1973 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 1974 1975 if (Args.hasArg(options::OPT_fpie)) 1976 CmdArgs.push_back("-pie"); 1977 1978 Args.AddLastArg(CmdArgs, options::OPT_prebind); 1979 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 1980 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 1981 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 1982 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 1983 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 1984 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 1985 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 1986 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 1987 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 1988 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 1989 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 1990 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 1991 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 1992 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 1993 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 1994 1995 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 1996 if (getDarwinToolChain().isIPhoneOS()) { 1997 if (!Args.hasArg(options::OPT_isysroot)) { 1998 CmdArgs.push_back("-syslibroot"); 1999 CmdArgs.push_back("/Developer/SDKs/Extra"); 2000 } 2001 } 2002 2003 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 2004 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 2005 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 2006 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 2007 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 2008 2009 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 2010 if (!Args.hasArg(options::OPT_weak__reference__mismatches)) { 2011 CmdArgs.push_back("-weak_reference_mismatches"); 2012 CmdArgs.push_back("non-weak"); 2013 } 2014 2015 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 2016 Args.AddAllArgs(CmdArgs, options::OPT_y); 2017 Args.AddLastArg(CmdArgs, options::OPT_w); 2018 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 2019 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 2020 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 2021 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 2022 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 2023 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 2024 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 2025 Args.AddLastArg(CmdArgs, options::OPT_whyload); 2026 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 2027 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 2028 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 2029 Args.AddLastArg(CmdArgs, options::OPT_Mach); 2030} 2031 2032void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 2033 Job &Dest, const InputInfo &Output, 2034 const InputInfoList &Inputs, 2035 const ArgList &Args, 2036 const char *LinkingOutput) const { 2037 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 2038 2039 // The logic here is derived from gcc's behavior; most of which 2040 // comes from specs (starting with link_command). Consult gcc for 2041 // more information. 2042 ArgStringList CmdArgs; 2043 2044 // I'm not sure why this particular decomposition exists in gcc, but 2045 // we follow suite for ease of comparison. 2046 AddLinkArgs(Args, CmdArgs); 2047 2048 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 2049 Args.AddAllArgs(CmdArgs, options::OPT_s); 2050 Args.AddAllArgs(CmdArgs, options::OPT_t); 2051 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 2052 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 2053 Args.AddAllArgs(CmdArgs, options::OPT_A); 2054 Args.AddLastArg(CmdArgs, options::OPT_e); 2055 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 2056 Args.AddAllArgs(CmdArgs, options::OPT_r); 2057 2058 CmdArgs.push_back("-o"); 2059 CmdArgs.push_back(Output.getFilename()); 2060 2061 2062 unsigned MacosxVersionMin[3]; 2063 getDarwinToolChain().getMacosxVersionMin(Args, MacosxVersionMin); 2064 2065 if (!Args.hasArg(options::OPT_A) && 2066 !Args.hasArg(options::OPT_nostdlib) && 2067 !Args.hasArg(options::OPT_nostartfiles)) { 2068 // Derived from startfile spec. 2069 if (Args.hasArg(options::OPT_dynamiclib)) { 2070 // Derived from darwin_dylib1 spec. 2071 if (getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 10, 5)) 2072 CmdArgs.push_back("-ldylib1.o"); 2073 else if (getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 10, 6)) 2074 CmdArgs.push_back("-ldylib1.10.5.o"); 2075 } else { 2076 if (Args.hasArg(options::OPT_bundle)) { 2077 if (!Args.hasArg(options::OPT_static)) { 2078 // Derived from darwin_bundle1 spec. 2079 if (getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 10, 6)) 2080 CmdArgs.push_back("-lbundle1.o"); 2081 } 2082 } else { 2083 if (Args.hasArg(options::OPT_pg)) { 2084 if (Args.hasArg(options::OPT_static) || 2085 Args.hasArg(options::OPT_object) || 2086 Args.hasArg(options::OPT_preload)) { 2087 CmdArgs.push_back("-lgcrt0.o"); 2088 } else { 2089 CmdArgs.push_back("-lgcrt1.o"); 2090 2091 // darwin_crt2 spec is empty. 2092 } 2093 } else { 2094 if (Args.hasArg(options::OPT_static) || 2095 Args.hasArg(options::OPT_object) || 2096 Args.hasArg(options::OPT_preload)) { 2097 CmdArgs.push_back("-lcrt0.o"); 2098 } else { 2099 // Derived from darwin_crt1 spec. 2100 if (getDarwinToolChain().isIPhoneOS()) { 2101 CmdArgs.push_back("-lcrt1.o"); 2102 } else if (getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 2103 10, 5)) 2104 CmdArgs.push_back("-lcrt1.o"); 2105 else if (getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 2106 10, 6)) 2107 CmdArgs.push_back("-lcrt1.10.5.o"); 2108 else 2109 CmdArgs.push_back("-lcrt1.10.6.o"); 2110 2111 // darwin_crt2 spec is empty. 2112 } 2113 } 2114 } 2115 } 2116 2117 if (Args.hasArg(options::OPT_shared_libgcc) && 2118 !Args.hasArg(options::OPT_miphoneos_version_min_EQ) && 2119 getDarwinToolChain().isMacosxVersionLT(MacosxVersionMin, 10, 5)) { 2120 const char *Str = 2121 Args.MakeArgString(getToolChain().GetFilePath(C, "crt3.o")); 2122 CmdArgs.push_back(Str); 2123 } 2124 } 2125 2126 Args.AddAllArgs(CmdArgs, options::OPT_L); 2127 2128 if (Args.hasArg(options::OPT_fopenmp)) 2129 // This is more complicated in gcc... 2130 CmdArgs.push_back("-lgomp"); 2131 2132 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs); 2133 2134 for (InputInfoList::const_iterator 2135 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2136 const InputInfo &II = *it; 2137 if (II.isFilename()) 2138 CmdArgs.push_back(II.getFilename()); 2139 else 2140 II.getInputArg().renderAsInput(Args, CmdArgs); 2141 } 2142 2143 if (LinkingOutput) { 2144 CmdArgs.push_back("-arch_multiple"); 2145 CmdArgs.push_back("-final_output"); 2146 CmdArgs.push_back(LinkingOutput); 2147 } 2148 2149 if (Args.hasArg(options::OPT_fprofile_arcs) || 2150 Args.hasArg(options::OPT_fprofile_generate) || 2151 Args.hasArg(options::OPT_fcreate_profile) || 2152 Args.hasArg(options::OPT_coverage)) 2153 CmdArgs.push_back("-lgcov"); 2154 2155 if (Args.hasArg(options::OPT_fnested_functions)) 2156 CmdArgs.push_back("-allow_stack_execute"); 2157 2158 if (!Args.hasArg(options::OPT_nostdlib) && 2159 !Args.hasArg(options::OPT_nodefaultlibs)) { 2160 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 2161 // before -lm, for example. 2162 if (getToolChain().getHost().getDriver().CCCIsCXX) 2163 CmdArgs.push_back("-lstdc++"); 2164 2165 // link_ssp spec is empty. 2166 2167 // Let the tool chain choose which runtime library to link. 2168 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 2169 } 2170 2171 if (!Args.hasArg(options::OPT_A) && 2172 !Args.hasArg(options::OPT_nostdlib) && 2173 !Args.hasArg(options::OPT_nostartfiles)) { 2174 // endfile_spec is empty. 2175 } 2176 2177 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2178 Args.AddAllArgs(CmdArgs, options::OPT_F); 2179 2180 const char *Exec = 2181 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2182 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2183 2184 // Find the first non-empty base input (we want to ignore linker 2185 // inputs). 2186 const char *BaseInput = ""; 2187 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 2188 if (Inputs[i].getBaseInput()[0] != '\0') { 2189 BaseInput = Inputs[i].getBaseInput(); 2190 break; 2191 } 2192 } 2193 2194 // Run dsymutil if we are making an executable in a single step. 2195 // 2196 // FIXME: Currently we don't want to do this when we are part of a 2197 // universal build step, as this would end up creating stray temp 2198 // files. 2199 if (!LinkingOutput && 2200 Args.getLastArg(options::OPT_g_Group) && 2201 !Args.getLastArg(options::OPT_gstabs) && 2202 !Args.getLastArg(options::OPT_g0)) { 2203 // FIXME: This is gross, but matches gcc. The test only considers 2204 // the suffix (not the -x type), and then only of the first 2205 // source input. Awesome. 2206 const char *Suffix = strrchr(BaseInput, '.'); 2207 if (Suffix && isSourceSuffix(Suffix + 1)) { 2208 const char *Exec = 2209 Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil")); 2210 ArgStringList CmdArgs; 2211 CmdArgs.push_back(Output.getFilename()); 2212 C.getJobs().addCommand(new Command(JA, Exec, CmdArgs)); 2213 } 2214 } 2215} 2216 2217void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 2218 Job &Dest, const InputInfo &Output, 2219 const InputInfoList &Inputs, 2220 const ArgList &Args, 2221 const char *LinkingOutput) const { 2222 ArgStringList CmdArgs; 2223 2224 CmdArgs.push_back("-create"); 2225 assert(Output.isFilename() && "Unexpected lipo output."); 2226 2227 CmdArgs.push_back("-output"); 2228 CmdArgs.push_back(Output.getFilename()); 2229 2230 for (InputInfoList::const_iterator 2231 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2232 const InputInfo &II = *it; 2233 assert(II.isFilename() && "Unexpected lipo input."); 2234 CmdArgs.push_back(II.getFilename()); 2235 } 2236 const char *Exec = 2237 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo")); 2238 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2239} 2240 2241void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2242 Job &Dest, const InputInfo &Output, 2243 const InputInfoList &Inputs, 2244 const ArgList &Args, 2245 const char *LinkingOutput) const { 2246 ArgStringList CmdArgs; 2247 2248 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2249 options::OPT_Xassembler); 2250 2251 CmdArgs.push_back("-o"); 2252 if (Output.isPipe()) 2253 CmdArgs.push_back("-"); 2254 else 2255 CmdArgs.push_back(Output.getFilename()); 2256 2257 for (InputInfoList::const_iterator 2258 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2259 const InputInfo &II = *it; 2260 if (II.isPipe()) 2261 CmdArgs.push_back("-"); 2262 else 2263 CmdArgs.push_back(II.getFilename()); 2264 } 2265 2266 const char *Exec = 2267 Args.MakeArgString(getToolChain().GetProgramPath(C, "gas")); 2268 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2269} 2270 2271void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 2272 Job &Dest, const InputInfo &Output, 2273 const InputInfoList &Inputs, 2274 const ArgList &Args, 2275 const char *LinkingOutput) const { 2276 const Driver &D = getToolChain().getHost().getDriver(); 2277 ArgStringList CmdArgs; 2278 2279 if ((!Args.hasArg(options::OPT_nostdlib)) && 2280 (!Args.hasArg(options::OPT_shared))) { 2281 CmdArgs.push_back("-e"); 2282 CmdArgs.push_back("_start"); 2283 } 2284 2285 if (Args.hasArg(options::OPT_static)) { 2286 CmdArgs.push_back("-Bstatic"); 2287 CmdArgs.push_back("-dn"); 2288 } else { 2289// CmdArgs.push_back("--eh-frame-hdr"); 2290 CmdArgs.push_back("-Bdynamic"); 2291 if (Args.hasArg(options::OPT_shared)) { 2292 CmdArgs.push_back("-shared"); 2293 } else { 2294 CmdArgs.push_back("--dynamic-linker"); 2295 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 2296 } 2297 } 2298 2299 if (Output.isPipe()) { 2300 CmdArgs.push_back("-o"); 2301 CmdArgs.push_back("-"); 2302 } else if (Output.isFilename()) { 2303 CmdArgs.push_back("-o"); 2304 CmdArgs.push_back(Output.getFilename()); 2305 } else { 2306 assert(Output.isNothing() && "Invalid output."); 2307 } 2308 2309 if (!Args.hasArg(options::OPT_nostdlib) && 2310 !Args.hasArg(options::OPT_nostartfiles)) { 2311 if (!Args.hasArg(options::OPT_shared)) { 2312 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2313 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2314 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2315 } else { 2316 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2317 } 2318 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2319 } 2320 2321 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 2322 + getToolChain().getTripleString() 2323 + "/4.2.4")); 2324 2325 Args.AddAllArgs(CmdArgs, options::OPT_L); 2326 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2327 Args.AddAllArgs(CmdArgs, options::OPT_e); 2328 2329 for (InputInfoList::const_iterator 2330 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2331 const InputInfo &II = *it; 2332 2333 // Don't try to pass LLVM inputs to a generic gcc. 2334 if (II.getType() == types::TY_LLVMBC) 2335 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2336 << getToolChain().getTripleString(); 2337 2338 if (II.isPipe()) 2339 CmdArgs.push_back("-"); 2340 else if (II.isFilename()) 2341 CmdArgs.push_back(II.getFilename()); 2342 else 2343 II.getInputArg().renderAsInput(Args, CmdArgs); 2344 } 2345 2346 if (!Args.hasArg(options::OPT_nostdlib) && 2347 !Args.hasArg(options::OPT_nodefaultlibs)) { 2348 // FIXME: For some reason GCC passes -lgcc before adding 2349 // the default system libraries. Just mimic this for now. 2350 CmdArgs.push_back("-lgcc"); 2351 2352 if (Args.hasArg(options::OPT_pthread)) 2353 CmdArgs.push_back("-pthread"); 2354 if (!Args.hasArg(options::OPT_shared)) 2355 CmdArgs.push_back("-lc"); 2356 CmdArgs.push_back("-lgcc"); 2357 } 2358 2359 if (!Args.hasArg(options::OPT_nostdlib) && 2360 !Args.hasArg(options::OPT_nostartfiles)) { 2361 if (!Args.hasArg(options::OPT_shared)) 2362 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2363// else 2364// CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2365 } 2366 2367 const char *Exec = 2368 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2369 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2370} 2371 2372void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2373 Job &Dest, const InputInfo &Output, 2374 const InputInfoList &Inputs, 2375 const ArgList &Args, 2376 const char *LinkingOutput) const { 2377 ArgStringList CmdArgs; 2378 2379 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2380 options::OPT_Xassembler); 2381 2382 CmdArgs.push_back("-o"); 2383 if (Output.isPipe()) 2384 CmdArgs.push_back("-"); 2385 else 2386 CmdArgs.push_back(Output.getFilename()); 2387 2388 for (InputInfoList::const_iterator 2389 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2390 const InputInfo &II = *it; 2391 if (II.isPipe()) 2392 CmdArgs.push_back("-"); 2393 else 2394 CmdArgs.push_back(II.getFilename()); 2395 } 2396 2397 const char *Exec = 2398 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2399 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2400} 2401 2402void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2403 Job &Dest, const InputInfo &Output, 2404 const InputInfoList &Inputs, 2405 const ArgList &Args, 2406 const char *LinkingOutput) const { 2407 const Driver &D = getToolChain().getHost().getDriver(); 2408 ArgStringList CmdArgs; 2409 2410 if ((!Args.hasArg(options::OPT_nostdlib)) && 2411 (!Args.hasArg(options::OPT_shared))) { 2412 CmdArgs.push_back("-e"); 2413 CmdArgs.push_back("__start"); 2414 } 2415 2416 if (Args.hasArg(options::OPT_static)) { 2417 CmdArgs.push_back("-Bstatic"); 2418 } else { 2419 CmdArgs.push_back("--eh-frame-hdr"); 2420 CmdArgs.push_back("-Bdynamic"); 2421 if (Args.hasArg(options::OPT_shared)) { 2422 CmdArgs.push_back("-shared"); 2423 } else { 2424 CmdArgs.push_back("-dynamic-linker"); 2425 CmdArgs.push_back("/usr/libexec/ld.so"); 2426 } 2427 } 2428 2429 if (Output.isPipe()) { 2430 CmdArgs.push_back("-o"); 2431 CmdArgs.push_back("-"); 2432 } else if (Output.isFilename()) { 2433 CmdArgs.push_back("-o"); 2434 CmdArgs.push_back(Output.getFilename()); 2435 } else { 2436 assert(Output.isNothing() && "Invalid output."); 2437 } 2438 2439 if (!Args.hasArg(options::OPT_nostdlib) && 2440 !Args.hasArg(options::OPT_nostartfiles)) { 2441 if (!Args.hasArg(options::OPT_shared)) { 2442 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt0.o"))); 2443 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2444 } else { 2445 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2446 } 2447 } 2448 2449 std::string Triple = getToolChain().getTripleString(); 2450 if (Triple.substr(0, 6) == "x86_64") 2451 Triple.replace(0, 6, "amd64"); 2452 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 2453 "/3.3.5")); 2454 2455 Args.AddAllArgs(CmdArgs, options::OPT_L); 2456 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2457 Args.AddAllArgs(CmdArgs, options::OPT_e); 2458 2459 for (InputInfoList::const_iterator 2460 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2461 const InputInfo &II = *it; 2462 2463 // Don't try to pass LLVM inputs to a generic gcc. 2464 if (II.getType() == types::TY_LLVMBC) 2465 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2466 << getToolChain().getTripleString(); 2467 2468 if (II.isPipe()) 2469 CmdArgs.push_back("-"); 2470 else if (II.isFilename()) 2471 CmdArgs.push_back(II.getFilename()); 2472 else 2473 II.getInputArg().renderAsInput(Args, CmdArgs); 2474 } 2475 2476 if (!Args.hasArg(options::OPT_nostdlib) && 2477 !Args.hasArg(options::OPT_nodefaultlibs)) { 2478 // FIXME: For some reason GCC passes -lgcc before adding 2479 // the default system libraries. Just mimic this for now. 2480 CmdArgs.push_back("-lgcc"); 2481 2482 if (Args.hasArg(options::OPT_pthread)) 2483 CmdArgs.push_back("-pthread"); 2484 if (!Args.hasArg(options::OPT_shared)) 2485 CmdArgs.push_back("-lc"); 2486 CmdArgs.push_back("-lgcc"); 2487 } 2488 2489 if (!Args.hasArg(options::OPT_nostdlib) && 2490 !Args.hasArg(options::OPT_nostartfiles)) { 2491 if (!Args.hasArg(options::OPT_shared)) 2492 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2493 else 2494 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2495 } 2496 2497 const char *Exec = 2498 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2499 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2500} 2501 2502void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2503 Job &Dest, const InputInfo &Output, 2504 const InputInfoList &Inputs, 2505 const ArgList &Args, 2506 const char *LinkingOutput) const { 2507 ArgStringList CmdArgs; 2508 2509 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2510 // instruct as in the base system to assemble 32-bit code. 2511 if (getToolChain().getArchName() == "i386") 2512 CmdArgs.push_back("--32"); 2513 2514 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2515 options::OPT_Xassembler); 2516 2517 CmdArgs.push_back("-o"); 2518 if (Output.isPipe()) 2519 CmdArgs.push_back("-"); 2520 else 2521 CmdArgs.push_back(Output.getFilename()); 2522 2523 for (InputInfoList::const_iterator 2524 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2525 const InputInfo &II = *it; 2526 if (II.isPipe()) 2527 CmdArgs.push_back("-"); 2528 else 2529 CmdArgs.push_back(II.getFilename()); 2530 } 2531 2532 const char *Exec = 2533 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2534 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2535} 2536 2537void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2538 Job &Dest, const InputInfo &Output, 2539 const InputInfoList &Inputs, 2540 const ArgList &Args, 2541 const char *LinkingOutput) const { 2542 const Driver &D = getToolChain().getHost().getDriver(); 2543 ArgStringList CmdArgs; 2544 2545 if (Args.hasArg(options::OPT_static)) { 2546 CmdArgs.push_back("-Bstatic"); 2547 } else { 2548 CmdArgs.push_back("--eh-frame-hdr"); 2549 if (Args.hasArg(options::OPT_shared)) { 2550 CmdArgs.push_back("-Bshareable"); 2551 } else { 2552 CmdArgs.push_back("-dynamic-linker"); 2553 CmdArgs.push_back("/libexec/ld-elf.so.1"); 2554 } 2555 } 2556 2557 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2558 // instruct ld in the base system to link 32-bit code. 2559 if (getToolChain().getArchName() == "i386") { 2560 CmdArgs.push_back("-m"); 2561 CmdArgs.push_back("elf_i386_fbsd"); 2562 } 2563 2564 if (Output.isPipe()) { 2565 CmdArgs.push_back("-o"); 2566 CmdArgs.push_back("-"); 2567 } else if (Output.isFilename()) { 2568 CmdArgs.push_back("-o"); 2569 CmdArgs.push_back(Output.getFilename()); 2570 } else { 2571 assert(Output.isNothing() && "Invalid output."); 2572 } 2573 2574 if (!Args.hasArg(options::OPT_nostdlib) && 2575 !Args.hasArg(options::OPT_nostartfiles)) { 2576 if (!Args.hasArg(options::OPT_shared)) { 2577 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2578 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2579 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2580 } else { 2581 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2582 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2583 } 2584 } 2585 2586 Args.AddAllArgs(CmdArgs, options::OPT_L); 2587 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2588 Args.AddAllArgs(CmdArgs, options::OPT_e); 2589 2590 for (InputInfoList::const_iterator 2591 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2592 const InputInfo &II = *it; 2593 2594 // Don't try to pass LLVM inputs to a generic gcc. 2595 if (II.getType() == types::TY_LLVMBC) 2596 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2597 << getToolChain().getTripleString(); 2598 2599 if (II.isPipe()) 2600 CmdArgs.push_back("-"); 2601 else if (II.isFilename()) 2602 CmdArgs.push_back(II.getFilename()); 2603 else 2604 II.getInputArg().renderAsInput(Args, CmdArgs); 2605 } 2606 2607 if (!Args.hasArg(options::OPT_nostdlib) && 2608 !Args.hasArg(options::OPT_nodefaultlibs)) { 2609 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 2610 // the default system libraries. Just mimic this for now. 2611 CmdArgs.push_back("-lgcc"); 2612 if (Args.hasArg(options::OPT_static)) { 2613 CmdArgs.push_back("-lgcc_eh"); 2614 } else { 2615 CmdArgs.push_back("--as-needed"); 2616 CmdArgs.push_back("-lgcc_s"); 2617 CmdArgs.push_back("--no-as-needed"); 2618 } 2619 2620 if (Args.hasArg(options::OPT_pthread)) 2621 CmdArgs.push_back("-lpthread"); 2622 CmdArgs.push_back("-lc"); 2623 2624 CmdArgs.push_back("-lgcc"); 2625 if (Args.hasArg(options::OPT_static)) { 2626 CmdArgs.push_back("-lgcc_eh"); 2627 } else { 2628 CmdArgs.push_back("--as-needed"); 2629 CmdArgs.push_back("-lgcc_s"); 2630 CmdArgs.push_back("--no-as-needed"); 2631 } 2632 } 2633 2634 if (!Args.hasArg(options::OPT_nostdlib) && 2635 !Args.hasArg(options::OPT_nostartfiles)) { 2636 if (!Args.hasArg(options::OPT_shared)) 2637 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2638 else 2639 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2640 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2641 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 2642 // before -lm, for example. 2643 if (D.CCCIsCXX) 2644 CmdArgs.push_back("-lstdc++"); 2645 } 2646 2647 const char *Exec = 2648 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2649 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2650} 2651 2652/// DragonFly Tools 2653 2654// For now, DragonFly Assemble does just about the same as for 2655// FreeBSD, but this may change soon. 2656void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2657 Job &Dest, const InputInfo &Output, 2658 const InputInfoList &Inputs, 2659 const ArgList &Args, 2660 const char *LinkingOutput) const { 2661 ArgStringList CmdArgs; 2662 2663 // When building 32-bit code on DragonFly/pc64, we have to explicitly 2664 // instruct as in the base system to assemble 32-bit code. 2665 if (getToolChain().getArchName() == "i386") 2666 CmdArgs.push_back("--32"); 2667 2668 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2669 options::OPT_Xassembler); 2670 2671 CmdArgs.push_back("-o"); 2672 if (Output.isPipe()) 2673 CmdArgs.push_back("-"); 2674 else 2675 CmdArgs.push_back(Output.getFilename()); 2676 2677 for (InputInfoList::const_iterator 2678 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2679 const InputInfo &II = *it; 2680 if (II.isPipe()) 2681 CmdArgs.push_back("-"); 2682 else 2683 CmdArgs.push_back(II.getFilename()); 2684 } 2685 2686 const char *Exec = 2687 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2688 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2689} 2690 2691void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 2692 Job &Dest, const InputInfo &Output, 2693 const InputInfoList &Inputs, 2694 const ArgList &Args, 2695 const char *LinkingOutput) const { 2696 const Driver &D = getToolChain().getHost().getDriver(); 2697 ArgStringList CmdArgs; 2698 2699 if (Args.hasArg(options::OPT_static)) { 2700 CmdArgs.push_back("-Bstatic"); 2701 } else { 2702 if (Args.hasArg(options::OPT_shared)) 2703 CmdArgs.push_back("-Bshareable"); 2704 else { 2705 CmdArgs.push_back("-dynamic-linker"); 2706 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 2707 } 2708 } 2709 2710 // When building 32-bit code on DragonFly/pc64, we have to explicitly 2711 // instruct ld in the base system to link 32-bit code. 2712 if (getToolChain().getArchName() == "i386") { 2713 CmdArgs.push_back("-m"); 2714 CmdArgs.push_back("elf_i386"); 2715 } 2716 2717 if (Output.isPipe()) { 2718 CmdArgs.push_back("-o"); 2719 CmdArgs.push_back("-"); 2720 } else if (Output.isFilename()) { 2721 CmdArgs.push_back("-o"); 2722 CmdArgs.push_back(Output.getFilename()); 2723 } else { 2724 assert(Output.isNothing() && "Invalid output."); 2725 } 2726 2727 if (!Args.hasArg(options::OPT_nostdlib) && 2728 !Args.hasArg(options::OPT_nostartfiles)) { 2729 if (!Args.hasArg(options::OPT_shared)) { 2730 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2731 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2732 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2733 } else { 2734 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2735 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2736 } 2737 } 2738 2739 Args.AddAllArgs(CmdArgs, options::OPT_L); 2740 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2741 Args.AddAllArgs(CmdArgs, options::OPT_e); 2742 2743 for (InputInfoList::const_iterator 2744 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2745 const InputInfo &II = *it; 2746 2747 // Don't try to pass LLVM inputs to a generic gcc. 2748 if (II.getType() == types::TY_LLVMBC) 2749 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2750 << getToolChain().getTripleString(); 2751 2752 if (II.isPipe()) 2753 CmdArgs.push_back("-"); 2754 else if (II.isFilename()) 2755 CmdArgs.push_back(II.getFilename()); 2756 else 2757 II.getInputArg().renderAsInput(Args, CmdArgs); 2758 } 2759 2760 if (!Args.hasArg(options::OPT_nostdlib) && 2761 !Args.hasArg(options::OPT_nodefaultlibs)) { 2762 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 2763 // rpaths 2764 CmdArgs.push_back("-L/usr/lib/gcc41"); 2765 2766 if (!Args.hasArg(options::OPT_static)) { 2767 CmdArgs.push_back("-rpath"); 2768 CmdArgs.push_back("/usr/lib/gcc41"); 2769 2770 CmdArgs.push_back("-rpath-link"); 2771 CmdArgs.push_back("/usr/lib/gcc41"); 2772 2773 CmdArgs.push_back("-rpath"); 2774 CmdArgs.push_back("/usr/lib"); 2775 2776 CmdArgs.push_back("-rpath-link"); 2777 CmdArgs.push_back("/usr/lib"); 2778 } 2779 2780 if (Args.hasArg(options::OPT_shared)) { 2781 CmdArgs.push_back("-lgcc_pic"); 2782 } else { 2783 CmdArgs.push_back("-lgcc"); 2784 } 2785 2786 2787 if (Args.hasArg(options::OPT_pthread)) 2788 CmdArgs.push_back("-lpthread"); 2789 2790 if (!Args.hasArg(options::OPT_nolibc)) { 2791 CmdArgs.push_back("-lc"); 2792 } 2793 2794 if (Args.hasArg(options::OPT_shared)) { 2795 CmdArgs.push_back("-lgcc_pic"); 2796 } else { 2797 CmdArgs.push_back("-lgcc"); 2798 } 2799 } 2800 2801 if (!Args.hasArg(options::OPT_nostdlib) && 2802 !Args.hasArg(options::OPT_nostartfiles)) { 2803 if (!Args.hasArg(options::OPT_shared)) 2804 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2805 else 2806 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2807 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2808 } 2809 2810 const char *Exec = 2811 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2812 Dest.addCommand(new Command(JA, Exec, CmdArgs)); 2813} 2814