Tools.cpp revision 244640
1191783Srmacklem//===--- Tools.cpp - Tools Implementations --------------------------------===// 2191783Srmacklem// 3191783Srmacklem// The LLVM Compiler Infrastructure 4191783Srmacklem// 5191783Srmacklem// This file is distributed under the University of Illinois Open Source 6191783Srmacklem// License. See LICENSE.TXT for details. 7191783Srmacklem// 8191783Srmacklem//===----------------------------------------------------------------------===// 9191783Srmacklem 10191783Srmacklem#include "Tools.h" 11191783Srmacklem 12191783Srmacklem#include "clang/Driver/Action.h" 13191783Srmacklem#include "clang/Driver/Arg.h" 14191783Srmacklem#include "clang/Driver/ArgList.h" 15191783Srmacklem#include "clang/Driver/Driver.h" 16191783Srmacklem#include "clang/Driver/DriverDiagnostic.h" 17191783Srmacklem#include "clang/Driver/Compilation.h" 18191783Srmacklem#include "clang/Driver/Job.h" 19191783Srmacklem#include "clang/Driver/Option.h" 20191783Srmacklem#include "clang/Driver/Options.h" 21191783Srmacklem#include "clang/Driver/ToolChain.h" 22191783Srmacklem#include "clang/Driver/Util.h" 23191783Srmacklem#include "clang/Basic/ObjCRuntime.h" 24191783Srmacklem 25191783Srmacklem#include "llvm/ADT/SmallString.h" 26191783Srmacklem#include "llvm/ADT/StringSwitch.h" 27191783Srmacklem#include "llvm/ADT/Twine.h" 28191783Srmacklem#include "llvm/Support/FileSystem.h" 29191783Srmacklem#include "llvm/Support/Format.h" 30191783Srmacklem#include "llvm/Support/raw_ostream.h" 31191783Srmacklem#include "llvm/Support/Host.h" 32191783Srmacklem#include "llvm/Support/Process.h" 33191783Srmacklem#include "llvm/Support/ErrorHandling.h" 34191783Srmacklem 35191783Srmacklem#include "InputInfo.h" 36191783Srmacklem#include "SanitizerArgs.h" 37191783Srmacklem#include "ToolChains.h" 38191783Srmacklem 39191783Srmacklemusing namespace clang::driver; 40191783Srmacklemusing namespace clang::driver::tools; 41191783Srmacklemusing namespace clang; 42191783Srmacklem 43191783Srmacklem/// CheckPreprocessingOptions - Perform some validation of preprocessing 44191783Srmacklem/// arguments that is shared with gcc. 45191783Srmacklemstatic void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 46191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 47191783Srmacklem if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP) 48191783Srmacklem D.Diag(diag::err_drv_argument_only_allowed_with) 49191783Srmacklem << A->getAsString(Args) << "-E"; 50191783Srmacklem} 51191783Srmacklem 52193066Sjamie/// CheckCodeGenerationOptions - Perform some validation of code generation 53191783Srmacklem/// arguments that is shared with gcc. 54191783Srmacklemstatic void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 55191783Srmacklem // In gcc, only ARM checks this, but it seems reasonable to check universally. 56191783Srmacklem if (Args.hasArg(options::OPT_static)) 57191783Srmacklem if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 58191783Srmacklem options::OPT_mdynamic_no_pic)) 59191783Srmacklem D.Diag(diag::err_drv_argument_not_allowed_with) 60191783Srmacklem << A->getAsString(Args) << "-static"; 61191783Srmacklem} 62191783Srmacklem 63191783Srmacklem// Quote target names for inclusion in GNU Make dependency files. 64191783Srmacklem// Only the characters '$', '#', ' ', '\t' are quoted. 65191783Srmacklemstatic void QuoteTarget(StringRef Target, 66191783Srmacklem SmallVectorImpl<char> &Res) { 67191783Srmacklem for (unsigned i = 0, e = Target.size(); i != e; ++i) { 68191783Srmacklem switch (Target[i]) { 69191783Srmacklem case ' ': 70191783Srmacklem case '\t': 71191783Srmacklem // Escape the preceding backslashes 72191783Srmacklem for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j) 73191783Srmacklem Res.push_back('\\'); 74191783Srmacklem 75191783Srmacklem // Escape the space/tab 76191783Srmacklem Res.push_back('\\'); 77191783Srmacklem break; 78191783Srmacklem case '$': 79191783Srmacklem Res.push_back('$'); 80191783Srmacklem break; 81191783Srmacklem case '#': 82191783Srmacklem Res.push_back('\\'); 83191783Srmacklem break; 84191783Srmacklem default: 85191783Srmacklem break; 86191783Srmacklem } 87191783Srmacklem 88191783Srmacklem Res.push_back(Target[i]); 89191783Srmacklem } 90191783Srmacklem} 91191783Srmacklem 92191783Srmacklemstatic void addDirectoryList(const ArgList &Args, 93191783Srmacklem ArgStringList &CmdArgs, 94191783Srmacklem const char *ArgName, 95191783Srmacklem const char *EnvVar) { 96191783Srmacklem const char *DirList = ::getenv(EnvVar); 97191783Srmacklem bool CombinedArg = false; 98191783Srmacklem 99191783Srmacklem if (!DirList) 100191783Srmacklem return; // Nothing to do. 101191783Srmacklem 102191783Srmacklem StringRef Name(ArgName); 103191783Srmacklem if (Name.equals("-I") || Name.equals("-L")) 104191783Srmacklem CombinedArg = true; 105191783Srmacklem 106191783Srmacklem StringRef Dirs(DirList); 107191783Srmacklem if (Dirs.empty()) // Empty string should not add '.'. 108191783Srmacklem return; 109191783Srmacklem 110191783Srmacklem StringRef::size_type Delim; 111191783Srmacklem while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) { 112191783Srmacklem if (Delim == 0) { // Leading colon. 113191783Srmacklem if (CombinedArg) { 114191783Srmacklem CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 115191783Srmacklem } else { 116191783Srmacklem CmdArgs.push_back(ArgName); 117191783Srmacklem CmdArgs.push_back("."); 118191783Srmacklem } 119191783Srmacklem } else { 120191783Srmacklem if (CombinedArg) { 121191783Srmacklem CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim))); 122191783Srmacklem } else { 123191783Srmacklem CmdArgs.push_back(ArgName); 124191783Srmacklem CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim))); 125191783Srmacklem } 126191783Srmacklem } 127191783Srmacklem Dirs = Dirs.substr(Delim + 1); 128191783Srmacklem } 129191783Srmacklem 130191783Srmacklem if (Dirs.empty()) { // Trailing colon. 131191783Srmacklem if (CombinedArg) { 132191783Srmacklem CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 133191783Srmacklem } else { 134191783Srmacklem CmdArgs.push_back(ArgName); 135191783Srmacklem CmdArgs.push_back("."); 136191783Srmacklem } 137191783Srmacklem } else { // Add the last path. 138191783Srmacklem if (CombinedArg) { 139191783Srmacklem CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs)); 140191783Srmacklem } else { 141191783Srmacklem CmdArgs.push_back(ArgName); 142191783Srmacklem CmdArgs.push_back(Args.MakeArgString(Dirs)); 143191783Srmacklem } 144191783Srmacklem } 145191783Srmacklem} 146191783Srmacklem 147191783Srmacklemstatic void AddLinkerInputs(const ToolChain &TC, 148191783Srmacklem const InputInfoList &Inputs, const ArgList &Args, 149191783Srmacklem ArgStringList &CmdArgs) { 150191783Srmacklem const Driver &D = TC.getDriver(); 151191783Srmacklem 152191783Srmacklem // Add extra linker input arguments which are not treated as inputs 153191783Srmacklem // (constructed via -Xarch_). 154191783Srmacklem Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input); 155191783Srmacklem 156191783Srmacklem for (InputInfoList::const_iterator 157191783Srmacklem it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 158191783Srmacklem const InputInfo &II = *it; 159191783Srmacklem 160191783Srmacklem if (!TC.HasNativeLLVMSupport()) { 161191783Srmacklem // Don't try to pass LLVM inputs unless we have native support. 162191783Srmacklem if (II.getType() == types::TY_LLVM_IR || 163191783Srmacklem II.getType() == types::TY_LTO_IR || 164191783Srmacklem II.getType() == types::TY_LLVM_BC || 165191783Srmacklem II.getType() == types::TY_LTO_BC) 166191783Srmacklem D.Diag(diag::err_drv_no_linker_llvm_support) 167191783Srmacklem << TC.getTripleString(); 168191783Srmacklem } 169191783Srmacklem 170191783Srmacklem // Add filenames immediately. 171191783Srmacklem if (II.isFilename()) { 172191783Srmacklem CmdArgs.push_back(II.getFilename()); 173191783Srmacklem continue; 174191783Srmacklem } 175191783Srmacklem 176191783Srmacklem // Otherwise, this is a linker input argument. 177191783Srmacklem const Arg &A = II.getInputArg(); 178191783Srmacklem 179191783Srmacklem // Handle reserved library options. 180191783Srmacklem if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 181191783Srmacklem TC.AddCXXStdlibLibArgs(Args, CmdArgs); 182191783Srmacklem } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) { 183191783Srmacklem TC.AddCCKextLibArgs(Args, CmdArgs); 184191783Srmacklem } else 185191783Srmacklem A.renderAsInput(Args, CmdArgs); 186191783Srmacklem } 187191783Srmacklem 188191783Srmacklem // LIBRARY_PATH - included following the user specified library paths. 189192152Srmacklem addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH"); 190192152Srmacklem} 191192152Srmacklem 192192152Srmacklem/// \brief Determine whether Objective-C automated reference counting is 193192152Srmacklem/// enabled. 194192152Srmacklemstatic bool isObjCAutoRefCount(const ArgList &Args) { 195192152Srmacklem return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false); 196192152Srmacklem} 197192152Srmacklem 198192152Srmacklem/// \brief Determine whether we are linking the ObjC runtime. 199192152Srmacklemstatic bool isObjCRuntimeLinked(const ArgList &Args) { 200192152Srmacklem if (isObjCAutoRefCount(Args)) { 201192152Srmacklem Args.ClaimAllArgs(options::OPT_fobjc_link_runtime); 202192152Srmacklem return true; 203192152Srmacklem } 204192152Srmacklem return Args.hasArg(options::OPT_fobjc_link_runtime); 205192152Srmacklem} 206192152Srmacklem 207192152Srmacklemstatic void addProfileRT(const ToolChain &TC, const ArgList &Args, 208192152Srmacklem ArgStringList &CmdArgs, 209192152Srmacklem llvm::Triple Triple) { 210192152Srmacklem if (!(Args.hasArg(options::OPT_fprofile_arcs) || 211192152Srmacklem Args.hasArg(options::OPT_fprofile_generate) || 212192152Srmacklem Args.hasArg(options::OPT_fcreate_profile) || 213192152Srmacklem Args.hasArg(options::OPT_coverage))) 214192152Srmacklem return; 215192152Srmacklem 216192152Srmacklem // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to 217192152Srmacklem // the link line. We cannot do the same thing because unlike gcov there is a 218192152Srmacklem // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is 219192152Srmacklem // not supported by old linkers. 220192152Srmacklem std::string ProfileRT = 221192152Srmacklem std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a"; 222192152Srmacklem 223192152Srmacklem CmdArgs.push_back(Args.MakeArgString(ProfileRT)); 224192152Srmacklem} 225192152Srmacklem 226192152Srmacklemstatic bool forwardToGCC(const Option &O) { 227192152Srmacklem return !O.hasFlag(options::NoForward) && 228192152Srmacklem !O.hasFlag(options::DriverOption) && 229192152Srmacklem !O.hasFlag(options::LinkerInput); 230192152Srmacklem} 231192152Srmacklem 232192152Srmacklemvoid Clang::AddPreprocessingOptions(Compilation &C, 233192152Srmacklem const Driver &D, 234192152Srmacklem const ArgList &Args, 235192152Srmacklem ArgStringList &CmdArgs, 236192152Srmacklem const InputInfo &Output, 237192781Srmacklem const InputInfoList &Inputs) const { 238192781Srmacklem Arg *A; 239192781Srmacklem 240192152Srmacklem CheckPreprocessingOptions(D, Args); 241192152Srmacklem 242192152Srmacklem Args.AddLastArg(CmdArgs, options::OPT_C); 243192152Srmacklem Args.AddLastArg(CmdArgs, options::OPT_CC); 244192152Srmacklem 245192152Srmacklem // Handle dependency file generation. 246192152Srmacklem if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) || 247192152Srmacklem (A = Args.getLastArg(options::OPT_MD)) || 248192152Srmacklem (A = Args.getLastArg(options::OPT_MMD))) { 249192152Srmacklem // Determine the output location. 250192152Srmacklem const char *DepFile; 251192152Srmacklem if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 252192152Srmacklem DepFile = MF->getValue(); 253192152Srmacklem C.addFailureResultFile(DepFile); 254192152Srmacklem } else if (Output.getType() == types::TY_Dependencies) { 255192152Srmacklem DepFile = Output.getFilename(); 256192152Srmacklem } else if (A->getOption().matches(options::OPT_M) || 257192152Srmacklem A->getOption().matches(options::OPT_MM)) { 258192152Srmacklem DepFile = "-"; 259192152Srmacklem } else { 260192152Srmacklem DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 261192152Srmacklem C.addFailureResultFile(DepFile); 262192152Srmacklem } 263192152Srmacklem CmdArgs.push_back("-dependency-file"); 264192152Srmacklem CmdArgs.push_back(DepFile); 265192152Srmacklem 266192152Srmacklem // Add a default target if one wasn't specified. 267192152Srmacklem if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 268192152Srmacklem const char *DepTarget; 269192152Srmacklem 270192152Srmacklem // If user provided -o, that is the dependency target, except 271192152Srmacklem // when we are only generating a dependency file. 272192152Srmacklem Arg *OutputOpt = Args.getLastArg(options::OPT_o); 273192152Srmacklem if (OutputOpt && Output.getType() != types::TY_Dependencies) { 274192152Srmacklem DepTarget = OutputOpt->getValue(); 275192152Srmacklem } else { 276192152Srmacklem // Otherwise derive from the base input. 277192152Srmacklem // 278192152Srmacklem // FIXME: This should use the computed output file location. 279192152Srmacklem SmallString<128> P(Inputs[0].getBaseInput()); 280192152Srmacklem llvm::sys::path::replace_extension(P, "o"); 281192152Srmacklem DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 282192152Srmacklem } 283192152Srmacklem 284192152Srmacklem CmdArgs.push_back("-MT"); 285192152Srmacklem SmallString<128> Quoted; 286192152Srmacklem QuoteTarget(DepTarget, Quoted); 287192152Srmacklem CmdArgs.push_back(Args.MakeArgString(Quoted)); 288192152Srmacklem } 289192152Srmacklem 290192152Srmacklem if (A->getOption().matches(options::OPT_M) || 291192152Srmacklem A->getOption().matches(options::OPT_MD)) 292192152Srmacklem CmdArgs.push_back("-sys-header-deps"); 293192152Srmacklem } 294192152Srmacklem 295192152Srmacklem if (Args.hasArg(options::OPT_MG)) { 296192152Srmacklem if (!A || A->getOption().matches(options::OPT_MD) || 297192152Srmacklem A->getOption().matches(options::OPT_MMD)) 298192152Srmacklem D.Diag(diag::err_drv_mg_requires_m_or_mm); 299192152Srmacklem CmdArgs.push_back("-MG"); 300192152Srmacklem } 301192152Srmacklem 302192152Srmacklem Args.AddLastArg(CmdArgs, options::OPT_MP); 303192152Srmacklem 304192152Srmacklem // Convert all -MQ <target> args to -MT <quoted target> 305192152Srmacklem for (arg_iterator it = Args.filtered_begin(options::OPT_MT, 306192152Srmacklem options::OPT_MQ), 307192152Srmacklem ie = Args.filtered_end(); it != ie; ++it) { 308192152Srmacklem const Arg *A = *it; 309192152Srmacklem A->claim(); 310192152Srmacklem 311192152Srmacklem if (A->getOption().matches(options::OPT_MQ)) { 312192152Srmacklem CmdArgs.push_back("-MT"); 313192152Srmacklem SmallString<128> Quoted; 314192152Srmacklem QuoteTarget(A->getValue(), Quoted); 315192152Srmacklem CmdArgs.push_back(Args.MakeArgString(Quoted)); 316192152Srmacklem 317192152Srmacklem // -MT flag - no change 318192152Srmacklem } else { 319192152Srmacklem A->render(Args, CmdArgs); 320192152Srmacklem } 321192152Srmacklem } 322192152Srmacklem 323192152Srmacklem // Add -i* options, and automatically translate to 324192152Srmacklem // -include-pch/-include-pth for transparent PCH support. It's 325192152Srmacklem // wonky, but we include looking for .gch so we can support seamless 326192152Srmacklem // replacement into a build system already set up to be generating 327192152Srmacklem // .gch files. 328192152Srmacklem bool RenderedImplicitInclude = false; 329192152Srmacklem for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group), 330192152Srmacklem ie = Args.filtered_end(); it != ie; ++it) { 331192152Srmacklem const Arg *A = it; 332192152Srmacklem 333192152Srmacklem if (A->getOption().matches(options::OPT_include)) { 334192152Srmacklem bool IsFirstImplicitInclude = !RenderedImplicitInclude; 335192152Srmacklem RenderedImplicitInclude = true; 336192152Srmacklem 337192152Srmacklem // Use PCH if the user requested it. 338192152Srmacklem bool UsePCH = D.CCCUsePCH; 339192152Srmacklem 340192152Srmacklem bool FoundPTH = false; 341192152Srmacklem bool FoundPCH = false; 342192152Srmacklem llvm::sys::Path P(A->getValue()); 343192152Srmacklem bool Exists; 344192152Srmacklem if (UsePCH) { 345192152Srmacklem P.appendSuffix("pch"); 346192152Srmacklem if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 347192152Srmacklem FoundPCH = true; 348192152Srmacklem else 349192152Srmacklem P.eraseSuffix(); 350192152Srmacklem } 351192152Srmacklem 352192152Srmacklem if (!FoundPCH) { 353192152Srmacklem P.appendSuffix("pth"); 354192152Srmacklem if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 355192152Srmacklem FoundPTH = true; 356192152Srmacklem else 357192152Srmacklem P.eraseSuffix(); 358192152Srmacklem } 359192152Srmacklem 360192152Srmacklem if (!FoundPCH && !FoundPTH) { 361192152Srmacklem P.appendSuffix("gch"); 362192152Srmacklem if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) { 363192152Srmacklem FoundPCH = UsePCH; 364192152Srmacklem FoundPTH = !UsePCH; 365192152Srmacklem } 366192152Srmacklem else 367192152Srmacklem P.eraseSuffix(); 368191783Srmacklem } 369191783Srmacklem 370191783Srmacklem if (FoundPCH || FoundPTH) { 371191783Srmacklem if (IsFirstImplicitInclude) { 372191783Srmacklem A->claim(); 373191783Srmacklem if (UsePCH) 374191783Srmacklem CmdArgs.push_back("-include-pch"); 375191783Srmacklem else 376191783Srmacklem CmdArgs.push_back("-include-pth"); 377191783Srmacklem CmdArgs.push_back(Args.MakeArgString(P.str())); 378191783Srmacklem continue; 379191783Srmacklem } else { 380191783Srmacklem // Ignore the PCH if not first on command line and emit warning. 381191783Srmacklem D.Diag(diag::warn_drv_pch_not_first_include) 382191783Srmacklem << P.str() << A->getAsString(Args); 383191783Srmacklem } 384191783Srmacklem } 385191783Srmacklem } 386191783Srmacklem 387191783Srmacklem // Not translated, render as usual. 388191783Srmacklem A->claim(); 389191783Srmacklem A->render(Args, CmdArgs); 390191783Srmacklem } 391191783Srmacklem 392191783Srmacklem Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 393191783Srmacklem Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F, 394191783Srmacklem options::OPT_index_header_map); 395191783Srmacklem 396191783Srmacklem // Add -Wp, and -Xassembler if using the preprocessor. 397191783Srmacklem 398191783Srmacklem // FIXME: There is a very unfortunate problem here, some troubled 399191783Srmacklem // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 400191783Srmacklem // really support that we would have to parse and then translate 401191783Srmacklem // those options. :( 402191783Srmacklem Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 403191783Srmacklem options::OPT_Xpreprocessor); 404191783Srmacklem 405191783Srmacklem // -I- is a deprecated GCC feature, reject it. 406191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_I_)) 407191783Srmacklem D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 408191783Srmacklem 409191783Srmacklem // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 410191783Srmacklem // -isysroot to the CC1 invocation. 411191783Srmacklem StringRef sysroot = C.getSysRoot(); 412191783Srmacklem if (sysroot != "") { 413191783Srmacklem if (!Args.hasArg(options::OPT_isysroot)) { 414191783Srmacklem CmdArgs.push_back("-isysroot"); 415191783Srmacklem CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 416191783Srmacklem } 417191783Srmacklem } 418191783Srmacklem 419191783Srmacklem // If a module path was provided, pass it along. Otherwise, use a temporary 420191783Srmacklem // directory. 421191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) { 422191783Srmacklem A->claim(); 423191783Srmacklem A->render(Args, CmdArgs); 424191783Srmacklem } else { 425191783Srmacklem SmallString<128> DefaultModuleCache; 426191783Srmacklem llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, 427191783Srmacklem DefaultModuleCache); 428191783Srmacklem llvm::sys::path::append(DefaultModuleCache, "clang-module-cache"); 429191783Srmacklem CmdArgs.push_back("-fmodule-cache-path"); 430191783Srmacklem CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache)); 431191783Srmacklem } 432191783Srmacklem 433191783Srmacklem // Parse additional include paths from environment variables. 434191783Srmacklem // FIXME: We should probably sink the logic for handling these from the 435191783Srmacklem // frontend into the driver. It will allow deleting 4 otherwise unused flags. 436191783Srmacklem // CPATH - included following the user specified includes (but prior to 437191783Srmacklem // builtin and standard includes). 438191783Srmacklem addDirectoryList(Args, CmdArgs, "-I", "CPATH"); 439191783Srmacklem // C_INCLUDE_PATH - system includes enabled when compiling C. 440191783Srmacklem addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH"); 441191783Srmacklem // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++. 442191783Srmacklem addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH"); 443191783Srmacklem // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC. 444191783Srmacklem addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH"); 445191783Srmacklem // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++. 446191783Srmacklem addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH"); 447191783Srmacklem 448191783Srmacklem // Add C++ include arguments, if needed. 449191783Srmacklem if (types::isCXX(Inputs[0].getType())) 450191783Srmacklem getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs); 451191783Srmacklem 452191783Srmacklem // Add system include arguments. 453191783Srmacklem getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs); 454191783Srmacklem} 455191783Srmacklem 456191783Srmacklem/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 457191783Srmacklem/// CPU. 458191783Srmacklem// 459191783Srmacklem// FIXME: This is redundant with -mcpu, why does LLVM use this. 460191783Srmacklem// FIXME: tblgen this, or kill it! 461191783Srmacklemstatic const char *getLLVMArchSuffixForARM(StringRef CPU) { 462191783Srmacklem return llvm::StringSwitch<const char *>(CPU) 463191783Srmacklem .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t") 464191783Srmacklem .Cases("arm720t", "arm9", "arm9tdmi", "v4t") 465191783Srmacklem .Cases("arm920", "arm920t", "arm922t", "v4t") 466191783Srmacklem .Cases("arm940t", "ep9312","v4t") 467191783Srmacklem .Cases("arm10tdmi", "arm1020t", "v5") 468191783Srmacklem .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e") 469191783Srmacklem .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e") 470191783Srmacklem .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e") 471191783Srmacklem .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6") 472191783Srmacklem .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6") 473191783Srmacklem .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2") 474191783Srmacklem .Cases("cortex-a8", "cortex-a9", "cortex-a15", "v7") 475191783Srmacklem .Case("cortex-m3", "v7m") 476191783Srmacklem .Case("cortex-m4", "v7m") 477191783Srmacklem .Case("cortex-m0", "v6m") 478191783Srmacklem .Case("cortex-a9-mp", "v7f") 479191783Srmacklem .Case("swift", "v7s") 480191783Srmacklem .Default(""); 481191783Srmacklem} 482191783Srmacklem 483191783Srmacklem/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. 484191783Srmacklem// 485191783Srmacklem// FIXME: tblgen this. 486191783Srmacklemstatic std::string getARMTargetCPU(const ArgList &Args, 487191783Srmacklem const llvm::Triple &Triple) { 488191783Srmacklem // FIXME: Warn on inconsistent use of -mcpu and -march. 489191783Srmacklem 490191783Srmacklem // If we have -mcpu=, use that. 491191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 492191783Srmacklem StringRef MCPU = A->getValue(); 493191783Srmacklem // Handle -mcpu=native. 494191783Srmacklem if (MCPU == "native") 495191783Srmacklem return llvm::sys::getHostCPUName(); 496191783Srmacklem else 497191783Srmacklem return MCPU; 498191783Srmacklem } 499191783Srmacklem 500191783Srmacklem StringRef MArch; 501191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 502191783Srmacklem // Otherwise, if we have -march= choose the base CPU for that arch. 503191783Srmacklem MArch = A->getValue(); 504191783Srmacklem } else { 505191783Srmacklem // Otherwise, use the Arch from the triple. 506191783Srmacklem MArch = Triple.getArchName(); 507191783Srmacklem } 508191783Srmacklem 509191783Srmacklem // Handle -march=native. 510191783Srmacklem std::string NativeMArch; 511191783Srmacklem if (MArch == "native") { 512191783Srmacklem std::string CPU = llvm::sys::getHostCPUName(); 513191783Srmacklem if (CPU != "generic") { 514191783Srmacklem // Translate the native cpu into the architecture. The switch below will 515191783Srmacklem // then chose the minimum cpu for that arch. 516191783Srmacklem NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU); 517191783Srmacklem MArch = NativeMArch; 518191783Srmacklem } 519191783Srmacklem } 520191783Srmacklem 521191783Srmacklem return llvm::StringSwitch<const char *>(MArch) 522191783Srmacklem .Cases("armv2", "armv2a","arm2") 523191783Srmacklem .Case("armv3", "arm6") 524191783Srmacklem .Case("armv3m", "arm7m") 525191783Srmacklem .Cases("armv4", "armv4t", "arm7tdmi") 526191783Srmacklem .Cases("armv5", "armv5t", "arm10tdmi") 527191783Srmacklem .Cases("armv5e", "armv5te", "arm1022e") 528191783Srmacklem .Case("armv5tej", "arm926ej-s") 529191783Srmacklem .Cases("armv6", "armv6k", "arm1136jf-s") 530191783Srmacklem .Case("armv6j", "arm1136j-s") 531191783Srmacklem .Cases("armv6z", "armv6zk", "arm1176jzf-s") 532191783Srmacklem .Case("armv6t2", "arm1156t2-s") 533191783Srmacklem .Cases("armv7", "armv7a", "armv7-a", "cortex-a8") 534191783Srmacklem .Cases("armv7f", "armv7-f", "cortex-a9-mp") 535191783Srmacklem .Cases("armv7s", "armv7-s", "swift") 536191783Srmacklem .Cases("armv7r", "armv7-r", "cortex-r4") 537191783Srmacklem .Cases("armv7m", "armv7-m", "cortex-m3") 538191783Srmacklem .Case("ep9312", "ep9312") 539191783Srmacklem .Case("iwmmxt", "iwmmxt") 540191783Srmacklem .Case("xscale", "xscale") 541191783Srmacklem .Cases("armv6m", "armv6-m", "cortex-m0") 542191783Srmacklem // If all else failed, return the most base CPU LLVM supports. 543191783Srmacklem .Default("arm7tdmi"); 544191783Srmacklem} 545191783Srmacklem 546191783Srmacklem// FIXME: Move to target hook. 547191783Srmacklemstatic bool isSignedCharDefault(const llvm::Triple &Triple) { 548191783Srmacklem switch (Triple.getArch()) { 549191783Srmacklem default: 550191783Srmacklem return true; 551191783Srmacklem 552191783Srmacklem case llvm::Triple::arm: 553191783Srmacklem case llvm::Triple::ppc: 554191783Srmacklem case llvm::Triple::ppc64: 555191783Srmacklem if (Triple.isOSDarwin()) 556191783Srmacklem return true; 557191783Srmacklem return false; 558191783Srmacklem } 559191783Srmacklem} 560191783Srmacklem 561191783Srmacklem// Handle -mfpu=. 562191783Srmacklem// 563191783Srmacklem// FIXME: Centralize feature selection, defaulting shouldn't be also in the 564191783Srmacklem// frontend target. 565191783Srmacklemstatic void addFPUArgs(const Driver &D, const Arg *A, const ArgList &Args, 566191783Srmacklem ArgStringList &CmdArgs) { 567191783Srmacklem StringRef FPU = A->getValue(); 568191783Srmacklem 569191783Srmacklem // Set the target features based on the FPU. 570191783Srmacklem if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") { 571191783Srmacklem // Disable any default FPU support. 572191783Srmacklem CmdArgs.push_back("-target-feature"); 573191783Srmacklem CmdArgs.push_back("-vfp2"); 574191783Srmacklem CmdArgs.push_back("-target-feature"); 575191783Srmacklem CmdArgs.push_back("-vfp3"); 576191783Srmacklem CmdArgs.push_back("-target-feature"); 577191783Srmacklem CmdArgs.push_back("-neon"); 578191783Srmacklem } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") { 579191783Srmacklem CmdArgs.push_back("-target-feature"); 580191783Srmacklem CmdArgs.push_back("+vfp3"); 581191783Srmacklem CmdArgs.push_back("-target-feature"); 582191783Srmacklem CmdArgs.push_back("+d16"); 583191783Srmacklem CmdArgs.push_back("-target-feature"); 584191783Srmacklem CmdArgs.push_back("-neon"); 585191783Srmacklem } else if (FPU == "vfp") { 586191783Srmacklem CmdArgs.push_back("-target-feature"); 587191783Srmacklem CmdArgs.push_back("+vfp2"); 588191783Srmacklem CmdArgs.push_back("-target-feature"); 589191783Srmacklem CmdArgs.push_back("-neon"); 590191783Srmacklem } else if (FPU == "vfp3" || FPU == "vfpv3") { 591191783Srmacklem CmdArgs.push_back("-target-feature"); 592191783Srmacklem CmdArgs.push_back("+vfp3"); 593191783Srmacklem CmdArgs.push_back("-target-feature"); 594191783Srmacklem CmdArgs.push_back("-neon"); 595191783Srmacklem } else if (FPU == "neon") { 596191783Srmacklem CmdArgs.push_back("-target-feature"); 597191783Srmacklem CmdArgs.push_back("+neon"); 598191783Srmacklem } else 599191783Srmacklem D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 600191783Srmacklem} 601191783Srmacklem 602191783Srmacklem// Handle -mfpmath=. 603191783Srmacklemstatic void addFPMathArgs(const Driver &D, const Arg *A, const ArgList &Args, 604191783Srmacklem ArgStringList &CmdArgs, StringRef CPU) { 605191783Srmacklem StringRef FPMath = A->getValue(); 606191783Srmacklem 607191783Srmacklem // Set the target features based on the FPMath. 608191783Srmacklem if (FPMath == "neon") { 609191783Srmacklem CmdArgs.push_back("-target-feature"); 610191783Srmacklem CmdArgs.push_back("+neonfp"); 611191783Srmacklem 612191783Srmacklem if (CPU != "cortex-a8" && CPU != "cortex-a9" && CPU != "cortex-a9-mp" && 613191783Srmacklem CPU != "cortex-a15") 614191783Srmacklem D.Diag(diag::err_drv_invalid_feature) << "-mfpmath=neon" << CPU; 615191783Srmacklem 616191783Srmacklem } else if (FPMath == "vfp" || FPMath == "vfp2" || FPMath == "vfp3" || 617191783Srmacklem FPMath == "vfp4") { 618191783Srmacklem CmdArgs.push_back("-target-feature"); 619191783Srmacklem CmdArgs.push_back("-neonfp"); 620191783Srmacklem 621191783Srmacklem // FIXME: Add warnings when disabling a feature not present for a given CPU. 622191783Srmacklem } else 623191783Srmacklem D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 624191783Srmacklem} 625191783Srmacklem 626191783Srmacklem// Select the float ABI as determined by -msoft-float, -mhard-float, and 627191783Srmacklem// -mfloat-abi=. 628191783Srmacklemstatic StringRef getARMFloatABI(const Driver &D, 629191783Srmacklem const ArgList &Args, 630191783Srmacklem const llvm::Triple &Triple) { 631194292Srmacklem StringRef FloatABI; 632191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 633191783Srmacklem options::OPT_mhard_float, 634191783Srmacklem options::OPT_mfloat_abi_EQ)) { 635191783Srmacklem if (A->getOption().matches(options::OPT_msoft_float)) 636191783Srmacklem FloatABI = "soft"; 637191783Srmacklem else if (A->getOption().matches(options::OPT_mhard_float)) 638191783Srmacklem FloatABI = "hard"; 639191783Srmacklem else { 640191783Srmacklem FloatABI = A->getValue(); 641191783Srmacklem if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 642191783Srmacklem D.Diag(diag::err_drv_invalid_mfloat_abi) 643191783Srmacklem << A->getAsString(Args); 644191783Srmacklem FloatABI = "soft"; 645191783Srmacklem } 646191783Srmacklem } 647191783Srmacklem } 648191783Srmacklem 649191783Srmacklem // If unspecified, choose the default based on the platform. 650191783Srmacklem if (FloatABI.empty()) { 651191783Srmacklem switch (Triple.getOS()) { 652191783Srmacklem case llvm::Triple::Darwin: 653191783Srmacklem case llvm::Triple::MacOSX: 654191783Srmacklem case llvm::Triple::IOS: { 655191783Srmacklem // Darwin defaults to "softfp" for v6 and v7. 656191783Srmacklem // 657191783Srmacklem // FIXME: Factor out an ARM class so we can cache the arch somewhere. 658191783Srmacklem std::string ArchName = 659191783Srmacklem getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 660191783Srmacklem if (StringRef(ArchName).startswith("v6") || 661191783Srmacklem StringRef(ArchName).startswith("v7")) 662191783Srmacklem FloatABI = "softfp"; 663191783Srmacklem else 664191783Srmacklem FloatABI = "soft"; 665191783Srmacklem break; 666191783Srmacklem } 667191783Srmacklem 668191783Srmacklem case llvm::Triple::FreeBSD: 669191783Srmacklem // FreeBSD defaults to soft float 670191783Srmacklem FloatABI = "soft"; 671191783Srmacklem break; 672191783Srmacklem 673191783Srmacklem default: 674191783Srmacklem switch(Triple.getEnvironment()) { 675191783Srmacklem case llvm::Triple::GNUEABIHF: 676191783Srmacklem FloatABI = "hard"; 677191783Srmacklem break; 678191783Srmacklem case llvm::Triple::GNUEABI: 679191783Srmacklem FloatABI = "softfp"; 680191783Srmacklem break; 681191783Srmacklem case llvm::Triple::EABI: 682191783Srmacklem // EABI is always AAPCS, and if it was not marked 'hard', it's softfp 683191783Srmacklem FloatABI = "softfp"; 684191783Srmacklem break; 685191783Srmacklem case llvm::Triple::Android: { 686191783Srmacklem std::string ArchName = 687191783Srmacklem getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 688191783Srmacklem if (StringRef(ArchName).startswith("v7")) 689191783Srmacklem FloatABI = "softfp"; 690191783Srmacklem else 691191783Srmacklem FloatABI = "soft"; 692191783Srmacklem break; 693191783Srmacklem } 694191783Srmacklem default: 695191783Srmacklem // Assume "soft", but warn the user we are guessing. 696191783Srmacklem FloatABI = "soft"; 697191783Srmacklem D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 698191783Srmacklem break; 699191783Srmacklem } 700191783Srmacklem } 701191783Srmacklem } 702191783Srmacklem 703191783Srmacklem return FloatABI; 704191783Srmacklem} 705191783Srmacklem 706191783Srmacklem 707191783Srmacklemvoid Clang::AddARMTargetArgs(const ArgList &Args, 708191783Srmacklem ArgStringList &CmdArgs, 709191783Srmacklem bool KernelOrKext) const { 710191783Srmacklem const Driver &D = getToolChain().getDriver(); 711191783Srmacklem // Get the effective triple, which takes into account the deployment target. 712191783Srmacklem std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 713191783Srmacklem llvm::Triple Triple(TripleStr); 714191783Srmacklem std::string CPUName = getARMTargetCPU(Args, Triple); 715191783Srmacklem 716191783Srmacklem // Select the ABI to use. 717191783Srmacklem // 718191783Srmacklem // FIXME: Support -meabi. 719191783Srmacklem const char *ABIName = 0; 720191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 721191783Srmacklem ABIName = A->getValue(); 722191783Srmacklem } else if (Triple.isOSDarwin()) { 723191783Srmacklem // The backend is hardwired to assume AAPCS for M-class processors, ensure 724191783Srmacklem // the frontend matches that. 725191783Srmacklem if (StringRef(CPUName).startswith("cortex-m")) { 726191783Srmacklem ABIName = "aapcs"; 727191783Srmacklem } else { 728191783Srmacklem ABIName = "apcs-gnu"; 729191783Srmacklem } 730191783Srmacklem } else { 731191783Srmacklem // Select the default based on the platform. 732191783Srmacklem switch(Triple.getEnvironment()) { 733191783Srmacklem case llvm::Triple::Android: 734191783Srmacklem case llvm::Triple::GNUEABI: 735191783Srmacklem case llvm::Triple::GNUEABIHF: 736191783Srmacklem ABIName = "aapcs-linux"; 737191783Srmacklem break; 738191783Srmacklem case llvm::Triple::EABI: 739191783Srmacklem ABIName = "aapcs"; 740191783Srmacklem break; 741191783Srmacklem default: 742191783Srmacklem ABIName = "apcs-gnu"; 743191783Srmacklem } 744191783Srmacklem } 745191783Srmacklem CmdArgs.push_back("-target-abi"); 746191783Srmacklem CmdArgs.push_back(ABIName); 747191783Srmacklem 748191783Srmacklem // Set the CPU based on -march= and -mcpu=. 749191783Srmacklem CmdArgs.push_back("-target-cpu"); 750191783Srmacklem CmdArgs.push_back(Args.MakeArgString(CPUName)); 751191783Srmacklem 752191783Srmacklem // Determine floating point ABI from the options & target defaults. 753191783Srmacklem StringRef FloatABI = getARMFloatABI(D, Args, Triple); 754191783Srmacklem if (FloatABI == "soft") { 755191783Srmacklem // Floating point operations and argument passing are soft. 756191783Srmacklem // 757191783Srmacklem // FIXME: This changes CPP defines, we need -target-soft-float. 758191783Srmacklem CmdArgs.push_back("-msoft-float"); 759191783Srmacklem CmdArgs.push_back("-mfloat-abi"); 760191783Srmacklem CmdArgs.push_back("soft"); 761191783Srmacklem } else if (FloatABI == "softfp") { 762191783Srmacklem // Floating point operations are hard, but argument passing is soft. 763191783Srmacklem CmdArgs.push_back("-mfloat-abi"); 764191783Srmacklem CmdArgs.push_back("soft"); 765191783Srmacklem } else { 766191783Srmacklem // Floating point operations and argument passing are hard. 767191783Srmacklem assert(FloatABI == "hard" && "Invalid float abi!"); 768191783Srmacklem CmdArgs.push_back("-mfloat-abi"); 769191783Srmacklem CmdArgs.push_back("hard"); 770191783Srmacklem } 771191783Srmacklem 772191783Srmacklem // Set appropriate target features for floating point mode. 773191783Srmacklem // 774191783Srmacklem // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these 775191783Srmacklem // yet (it uses the -mfloat-abi and -msoft-float options above), and it is 776191783Srmacklem // stripped out by the ARM target. 777191783Srmacklem 778191783Srmacklem // Use software floating point operations? 779191783Srmacklem if (FloatABI == "soft") { 780191783Srmacklem CmdArgs.push_back("-target-feature"); 781191783Srmacklem CmdArgs.push_back("+soft-float"); 782191783Srmacklem } 783191783Srmacklem 784191783Srmacklem // Use software floating point argument passing? 785191783Srmacklem if (FloatABI != "hard") { 786191783Srmacklem CmdArgs.push_back("-target-feature"); 787191783Srmacklem CmdArgs.push_back("+soft-float-abi"); 788191783Srmacklem } 789191783Srmacklem 790191783Srmacklem // Honor -mfpu=. 791192898Srmacklem if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) 792192898Srmacklem addFPUArgs(D, A, Args, CmdArgs); 793191783Srmacklem 794191783Srmacklem // Honor -mfpmath=. 795191783Srmacklem if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) 796191783Srmacklem addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple)); 797191783Srmacklem 798191783Srmacklem // Setting -msoft-float effectively disables NEON because of the GCC 799191783Srmacklem // implementation, although the same isn't true of VFP or VFP3. 800191783Srmacklem if (FloatABI == "soft") { 801191783Srmacklem CmdArgs.push_back("-target-feature"); 802191783Srmacklem CmdArgs.push_back("-neon"); 803191783Srmacklem } 804191783Srmacklem 805191783Srmacklem // Kernel code has more strict alignment requirements. 806191783Srmacklem if (KernelOrKext) { 807191783Srmacklem if (Triple.getOS() != llvm::Triple::IOS || Triple.isOSVersionLT(6)) { 808191783Srmacklem CmdArgs.push_back("-backend-option"); 809191783Srmacklem CmdArgs.push_back("-arm-long-calls"); 810191783Srmacklem } 811191783Srmacklem 812191783Srmacklem CmdArgs.push_back("-backend-option"); 813191783Srmacklem CmdArgs.push_back("-arm-strict-align"); 814191783Srmacklem 815191783Srmacklem // The kext linker doesn't know how to deal with movw/movt. 816191783Srmacklem CmdArgs.push_back("-backend-option"); 817191783Srmacklem CmdArgs.push_back("-arm-darwin-use-movt=0"); 818191783Srmacklem } 819191783Srmacklem 820191783Srmacklem // Setting -mno-global-merge disables the codegen global merge pass. Setting 821191783Srmacklem // -mglobal-merge has no effect as the pass is enabled by default. 822191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 823191783Srmacklem options::OPT_mno_global_merge)) { 824191783Srmacklem if (A->getOption().matches(options::OPT_mno_global_merge)) 825191783Srmacklem CmdArgs.push_back("-mno-global-merge"); 826191783Srmacklem } 827191783Srmacklem 828191783Srmacklem if (Args.hasArg(options::OPT_mno_implicit_float)) 829191783Srmacklem CmdArgs.push_back("-no-implicit-float"); 830191783Srmacklem} 831191783Srmacklem 832191783Srmacklem// Translate MIPS CPU name alias option to CPU name. 833191783Srmacklemstatic StringRef getMipsCPUFromAlias(const Arg &A) { 834191783Srmacklem if (A.getOption().matches(options::OPT_mips32)) 835191783Srmacklem return "mips32"; 836191783Srmacklem if (A.getOption().matches(options::OPT_mips32r2)) 837191783Srmacklem return "mips32r2"; 838191783Srmacklem if (A.getOption().matches(options::OPT_mips64)) 839191783Srmacklem return "mips64"; 840191783Srmacklem if (A.getOption().matches(options::OPT_mips64r2)) 841191783Srmacklem return "mips64r2"; 842191783Srmacklem llvm_unreachable("Unexpected option"); 843191783Srmacklem return ""; 844191783Srmacklem} 845191783Srmacklem 846191783Srmacklem// Get CPU and ABI names. They are not independent 847191783Srmacklem// so we have to calculate them together. 848191783Srmacklemstatic void getMipsCPUAndABI(const ArgList &Args, 849191783Srmacklem const ToolChain &TC, 850191783Srmacklem StringRef &CPUName, 851191783Srmacklem StringRef &ABIName) { 852191783Srmacklem const char *DefMips32CPU = "mips32"; 853191783Srmacklem const char *DefMips64CPU = "mips64"; 854191783Srmacklem 855191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_march_EQ, 856191783Srmacklem options::OPT_mcpu_EQ, 857191783Srmacklem options::OPT_mips_CPUs_Group)) { 858191783Srmacklem if (A->getOption().matches(options::OPT_mips_CPUs_Group)) 859191783Srmacklem CPUName = getMipsCPUFromAlias(*A); 860191783Srmacklem else 861191783Srmacklem CPUName = A->getValue(); 862191783Srmacklem } 863191783Srmacklem 864191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 865191783Srmacklem ABIName = A->getValue(); 866191783Srmacklem 867191783Srmacklem // Setup default CPU and ABI names. 868191783Srmacklem if (CPUName.empty() && ABIName.empty()) { 869191783Srmacklem switch (TC.getTriple().getArch()) { 870191783Srmacklem default: 871191783Srmacklem llvm_unreachable("Unexpected triple arch name"); 872191783Srmacklem case llvm::Triple::mips: 873191783Srmacklem case llvm::Triple::mipsel: 874191783Srmacklem CPUName = DefMips32CPU; 875191783Srmacklem break; 876191783Srmacklem case llvm::Triple::mips64: 877191783Srmacklem case llvm::Triple::mips64el: 878191783Srmacklem CPUName = DefMips64CPU; 879191783Srmacklem break; 880191783Srmacklem } 881191783Srmacklem } 882191783Srmacklem 883191783Srmacklem if (!ABIName.empty()) { 884191783Srmacklem // Deduce CPU name from ABI name. 885191783Srmacklem CPUName = llvm::StringSwitch<const char *>(ABIName) 886191783Srmacklem .Cases("o32", "eabi", DefMips32CPU) 887191783Srmacklem .Cases("n32", "n64", DefMips64CPU) 888191783Srmacklem .Default(""); 889191783Srmacklem } 890191783Srmacklem else if (!CPUName.empty()) { 891191783Srmacklem // Deduce ABI name from CPU name. 892191783Srmacklem ABIName = llvm::StringSwitch<const char *>(CPUName) 893191783Srmacklem .Cases("mips32", "mips32r2", "o32") 894191783Srmacklem .Cases("mips64", "mips64r2", "n64") 895191783Srmacklem .Default(""); 896191783Srmacklem } 897191783Srmacklem 898191783Srmacklem // FIXME: Warn on inconsistent cpu and abi usage. 899191783Srmacklem} 900191783Srmacklem 901191783Srmacklem// Select the MIPS float ABI as determined by -msoft-float, -mhard-float, 902191783Srmacklem// and -mfloat-abi=. 903191783Srmacklemstatic StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) { 904191783Srmacklem // Select the float ABI as determined by -msoft-float, -mhard-float, 905191783Srmacklem // and -mfloat-abi=. 906191783Srmacklem StringRef FloatABI; 907191783Srmacklem if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 908191783Srmacklem options::OPT_mhard_float, 909191783Srmacklem options::OPT_mfloat_abi_EQ)) { 910191783Srmacklem if (A->getOption().matches(options::OPT_msoft_float)) 911191783Srmacklem FloatABI = "soft"; 912191783Srmacklem else if (A->getOption().matches(options::OPT_mhard_float)) 913191783Srmacklem FloatABI = "hard"; 914191783Srmacklem else { 915191783Srmacklem FloatABI = A->getValue(); 916191783Srmacklem if (FloatABI != "soft" && FloatABI != "single" && FloatABI != "hard") { 917 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args); 918 FloatABI = "hard"; 919 } 920 } 921 } 922 923 // If unspecified, choose the default based on the platform. 924 if (FloatABI.empty()) { 925 // Assume "hard", because it's a default value used by gcc. 926 // When we start to recognize specific target MIPS processors, 927 // we will be able to select the default more correctly. 928 FloatABI = "hard"; 929 } 930 931 return FloatABI; 932} 933 934static void AddTargetFeature(const ArgList &Args, 935 ArgStringList &CmdArgs, 936 OptSpecifier OnOpt, 937 OptSpecifier OffOpt, 938 StringRef FeatureName) { 939 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) { 940 CmdArgs.push_back("-target-feature"); 941 if (A->getOption().matches(OnOpt)) 942 CmdArgs.push_back(Args.MakeArgString("+" + FeatureName)); 943 else 944 CmdArgs.push_back(Args.MakeArgString("-" + FeatureName)); 945 } 946} 947 948void Clang::AddMIPSTargetArgs(const ArgList &Args, 949 ArgStringList &CmdArgs) const { 950 const Driver &D = getToolChain().getDriver(); 951 StringRef CPUName; 952 StringRef ABIName; 953 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName); 954 955 CmdArgs.push_back("-target-cpu"); 956 CmdArgs.push_back(CPUName.data()); 957 958 CmdArgs.push_back("-target-abi"); 959 CmdArgs.push_back(ABIName.data()); 960 961 StringRef FloatABI = getMipsFloatABI(D, Args); 962 963 if (FloatABI == "soft") { 964 // Floating point operations and argument passing are soft. 965 CmdArgs.push_back("-msoft-float"); 966 CmdArgs.push_back("-mfloat-abi"); 967 CmdArgs.push_back("soft"); 968 969 // FIXME: Note, this is a hack. We need to pass the selected float 970 // mode to the MipsTargetInfoBase to define appropriate macros there. 971 // Now it is the only method. 972 CmdArgs.push_back("-target-feature"); 973 CmdArgs.push_back("+soft-float"); 974 } 975 else if (FloatABI == "single") { 976 // Restrict the use of hardware floating-point 977 // instructions to 32-bit operations. 978 CmdArgs.push_back("-target-feature"); 979 CmdArgs.push_back("+single-float"); 980 } 981 else { 982 // Floating point operations and argument passing are hard. 983 assert(FloatABI == "hard" && "Invalid float abi!"); 984 CmdArgs.push_back("-mfloat-abi"); 985 CmdArgs.push_back("hard"); 986 } 987 988 AddTargetFeature(Args, CmdArgs, 989 options::OPT_mips16, options::OPT_mno_mips16, 990 "mips16"); 991 AddTargetFeature(Args, CmdArgs, 992 options::OPT_mdsp, options::OPT_mno_dsp, 993 "dsp"); 994 AddTargetFeature(Args, CmdArgs, 995 options::OPT_mdspr2, options::OPT_mno_dspr2, 996 "dspr2"); 997 998 if (Arg *A = Args.getLastArg(options::OPT_G)) { 999 StringRef v = A->getValue(); 1000 CmdArgs.push_back("-mllvm"); 1001 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v)); 1002 A->claim(); 1003 } 1004} 1005 1006/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting. 1007static std::string getPPCTargetCPU(const ArgList &Args) { 1008 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 1009 StringRef CPUName = A->getValue(); 1010 1011 if (CPUName == "native") { 1012 std::string CPU = llvm::sys::getHostCPUName(); 1013 if (!CPU.empty() && CPU != "generic") 1014 return CPU; 1015 else 1016 return ""; 1017 } 1018 1019 return llvm::StringSwitch<const char *>(CPUName) 1020 .Case("common", "generic") 1021 .Case("440", "440") 1022 .Case("440fp", "440") 1023 .Case("450", "450") 1024 .Case("601", "601") 1025 .Case("602", "602") 1026 .Case("603", "603") 1027 .Case("603e", "603e") 1028 .Case("603ev", "603ev") 1029 .Case("604", "604") 1030 .Case("604e", "604e") 1031 .Case("620", "620") 1032 .Case("G3", "g3") 1033 .Case("7400", "7400") 1034 .Case("G4", "g4") 1035 .Case("7450", "7450") 1036 .Case("G4+", "g4+") 1037 .Case("750", "750") 1038 .Case("970", "970") 1039 .Case("G5", "g5") 1040 .Case("a2", "a2") 1041 .Case("e500mc", "e500mc") 1042 .Case("e5500", "e5500") 1043 .Case("power6", "pwr6") 1044 .Case("power7", "pwr7") 1045 .Case("powerpc", "ppc") 1046 .Case("powerpc64", "ppc64") 1047 .Default(""); 1048 } 1049 1050 return ""; 1051} 1052 1053void Clang::AddPPCTargetArgs(const ArgList &Args, 1054 ArgStringList &CmdArgs) const { 1055 std::string TargetCPUName = getPPCTargetCPU(Args); 1056 1057 // LLVM may default to generating code for the native CPU, 1058 // but, like gcc, we default to a more generic option for 1059 // each architecture. (except on Darwin) 1060 llvm::Triple Triple = getToolChain().getTriple(); 1061 if (TargetCPUName.empty() && !Triple.isOSDarwin()) { 1062 if (Triple.getArch() == llvm::Triple::ppc64) 1063 TargetCPUName = "ppc64"; 1064 else 1065 TargetCPUName = "ppc"; 1066 } 1067 1068 if (!TargetCPUName.empty()) { 1069 CmdArgs.push_back("-target-cpu"); 1070 CmdArgs.push_back(Args.MakeArgString(TargetCPUName.c_str())); 1071 } 1072} 1073 1074void Clang::AddSparcTargetArgs(const ArgList &Args, 1075 ArgStringList &CmdArgs) const { 1076 const Driver &D = getToolChain().getDriver(); 1077 1078 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 1079 CmdArgs.push_back("-target-cpu"); 1080 CmdArgs.push_back(A->getValue()); 1081 } 1082 1083 // Select the float ABI as determined by -msoft-float, -mhard-float, and 1084 StringRef FloatABI; 1085 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 1086 options::OPT_mhard_float)) { 1087 if (A->getOption().matches(options::OPT_msoft_float)) 1088 FloatABI = "soft"; 1089 else if (A->getOption().matches(options::OPT_mhard_float)) 1090 FloatABI = "hard"; 1091 } 1092 1093 // If unspecified, choose the default based on the platform. 1094 if (FloatABI.empty()) { 1095 switch (getToolChain().getTriple().getOS()) { 1096 default: 1097 // Assume "soft", but warn the user we are guessing. 1098 FloatABI = "soft"; 1099 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 1100 break; 1101 } 1102 } 1103 1104 if (FloatABI == "soft") { 1105 // Floating point operations and argument passing are soft. 1106 // 1107 // FIXME: This changes CPP defines, we need -target-soft-float. 1108 CmdArgs.push_back("-msoft-float"); 1109 CmdArgs.push_back("-target-feature"); 1110 CmdArgs.push_back("+soft-float"); 1111 } else { 1112 assert(FloatABI == "hard" && "Invalid float abi!"); 1113 CmdArgs.push_back("-mhard-float"); 1114 } 1115} 1116 1117void Clang::AddX86TargetArgs(const ArgList &Args, 1118 ArgStringList &CmdArgs) const { 1119 const bool isAndroid = 1120 getToolChain().getTriple().getEnvironment() == llvm::Triple::Android; 1121 if (!Args.hasFlag(options::OPT_mred_zone, 1122 options::OPT_mno_red_zone, 1123 true) || 1124 Args.hasArg(options::OPT_mkernel) || 1125 Args.hasArg(options::OPT_fapple_kext)) 1126 CmdArgs.push_back("-disable-red-zone"); 1127 1128 if (Args.hasFlag(options::OPT_msoft_float, 1129 options::OPT_mno_soft_float, 1130 false)) 1131 CmdArgs.push_back("-no-implicit-float"); 1132 1133 const char *CPUName = 0; 1134 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 1135 if (StringRef(A->getValue()) == "native") { 1136 // FIXME: Reject attempts to use -march=native unless the target matches 1137 // the host. 1138 // 1139 // FIXME: We should also incorporate the detected target features for use 1140 // with -native. 1141 std::string CPU = llvm::sys::getHostCPUName(); 1142 if (!CPU.empty() && CPU != "generic") 1143 CPUName = Args.MakeArgString(CPU); 1144 } else 1145 CPUName = A->getValue(); 1146 } 1147 1148 // Select the default CPU if none was given (or detection failed). 1149 if (!CPUName) { 1150 // FIXME: Need target hooks. 1151 if (getToolChain().getTriple().isOSDarwin()) { 1152 if (getToolChain().getArch() == llvm::Triple::x86_64) 1153 CPUName = "core2"; 1154 else if (getToolChain().getArch() == llvm::Triple::x86) 1155 CPUName = "yonah"; 1156 } else if (getToolChain().getOS().startswith("haiku")) { 1157 if (getToolChain().getArch() == llvm::Triple::x86_64) 1158 CPUName = "x86-64"; 1159 else if (getToolChain().getArch() == llvm::Triple::x86) 1160 CPUName = "i586"; 1161 } else if (getToolChain().getOS().startswith("openbsd")) { 1162 if (getToolChain().getArch() == llvm::Triple::x86_64) 1163 CPUName = "x86-64"; 1164 else if (getToolChain().getArch() == llvm::Triple::x86) 1165 CPUName = "i486"; 1166 } else if (getToolChain().getOS().startswith("bitrig")) { 1167 if (getToolChain().getArch() == llvm::Triple::x86_64) 1168 CPUName = "x86-64"; 1169 else if (getToolChain().getArch() == llvm::Triple::x86) 1170 CPUName = "i686"; 1171 } else if (getToolChain().getOS().startswith("freebsd")) { 1172 if (getToolChain().getArch() == llvm::Triple::x86_64) 1173 CPUName = "x86-64"; 1174 else if (getToolChain().getArch() == llvm::Triple::x86) 1175 CPUName = "i486"; 1176 } else if (getToolChain().getOS().startswith("netbsd")) { 1177 if (getToolChain().getArch() == llvm::Triple::x86_64) 1178 CPUName = "x86-64"; 1179 else if (getToolChain().getArch() == llvm::Triple::x86) 1180 CPUName = "i486"; 1181 } else { 1182 if (getToolChain().getArch() == llvm::Triple::x86_64) 1183 CPUName = "x86-64"; 1184 else if (getToolChain().getArch() == llvm::Triple::x86) 1185 // All x86 devices running Android have core2 as their common 1186 // denominator. This makes a better choice than pentium4. 1187 CPUName = isAndroid ? "core2" : "pentium4"; 1188 } 1189 } 1190 1191 if (CPUName) { 1192 CmdArgs.push_back("-target-cpu"); 1193 CmdArgs.push_back(CPUName); 1194 } 1195 1196 // The required algorithm here is slightly strange: the options are applied 1197 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets 1198 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse" 1199 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the 1200 // former correctly, but not the latter; handle directly-overridden 1201 // attributes here. 1202 llvm::StringMap<unsigned> PrevFeature; 1203 std::vector<const char*> Features; 1204 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group), 1205 ie = Args.filtered_end(); it != ie; ++it) { 1206 StringRef Name = (*it)->getOption().getName(); 1207 (*it)->claim(); 1208 1209 // Skip over "-m". 1210 assert(Name.startswith("m") && "Invalid feature name."); 1211 Name = Name.substr(1); 1212 1213 bool IsNegative = Name.startswith("no-"); 1214 if (IsNegative) 1215 Name = Name.substr(3); 1216 1217 unsigned& Prev = PrevFeature[Name]; 1218 if (Prev) 1219 Features[Prev - 1] = 0; 1220 Prev = Features.size() + 1; 1221 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 1222 } 1223 for (unsigned i = 0; i < Features.size(); i++) { 1224 if (Features[i]) { 1225 CmdArgs.push_back("-target-feature"); 1226 CmdArgs.push_back(Features[i]); 1227 } 1228 } 1229} 1230 1231static Arg* getLastHexagonArchArg (const ArgList &Args) 1232{ 1233 Arg * A = NULL; 1234 1235 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 1236 it != ie; ++it) { 1237 if ((*it)->getOption().matches(options::OPT_march_EQ) || 1238 (*it)->getOption().matches(options::OPT_mcpu_EQ)) { 1239 A = *it; 1240 A->claim(); 1241 } 1242 else if ((*it)->getOption().matches(options::OPT_m_Joined)){ 1243 StringRef Value = (*it)->getValue(0); 1244 if (Value.startswith("v")) { 1245 A = *it; 1246 A->claim(); 1247 } 1248 } 1249 } 1250 return A; 1251} 1252 1253static StringRef getHexagonTargetCPU(const ArgList &Args) 1254{ 1255 Arg *A; 1256 llvm::StringRef WhichHexagon; 1257 1258 // Select the default CPU (v4) if none was given or detection failed. 1259 if ((A = getLastHexagonArchArg (Args))) { 1260 WhichHexagon = A->getValue(); 1261 if (WhichHexagon == "") 1262 return "v4"; 1263 else 1264 return WhichHexagon; 1265 } 1266 else 1267 return "v4"; 1268} 1269 1270void Clang::AddHexagonTargetArgs(const ArgList &Args, 1271 ArgStringList &CmdArgs) const { 1272 llvm::Triple Triple = getToolChain().getTriple(); 1273 1274 CmdArgs.push_back("-target-cpu"); 1275 CmdArgs.push_back(Args.MakeArgString("hexagon" + getHexagonTargetCPU(Args))); 1276 CmdArgs.push_back("-fno-signed-char"); 1277 CmdArgs.push_back("-nobuiltininc"); 1278 1279 if (Args.hasArg(options::OPT_mqdsp6_compat)) 1280 CmdArgs.push_back("-mqdsp6-compat"); 1281 1282 if (Arg *A = Args.getLastArg(options::OPT_G, 1283 options::OPT_msmall_data_threshold_EQ)) { 1284 std::string SmallDataThreshold="-small-data-threshold="; 1285 SmallDataThreshold += A->getValue(); 1286 CmdArgs.push_back ("-mllvm"); 1287 CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold)); 1288 A->claim(); 1289 } 1290 1291 if (!Args.hasArg(options::OPT_fno_short_enums)) 1292 CmdArgs.push_back("-fshort-enums"); 1293 if (Args.getLastArg(options::OPT_mieee_rnd_near)) { 1294 CmdArgs.push_back ("-mllvm"); 1295 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near"); 1296 } 1297 CmdArgs.push_back ("-mllvm"); 1298 CmdArgs.push_back ("-machine-sink-split=0"); 1299} 1300 1301static bool 1302shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, 1303 const llvm::Triple &Triple) { 1304 // We use the zero-cost exception tables for Objective-C if the non-fragile 1305 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and 1306 // later. 1307 if (runtime.isNonFragile()) 1308 return true; 1309 1310 if (!Triple.isOSDarwin()) 1311 return false; 1312 1313 return (!Triple.isMacOSXVersionLT(10,5) && 1314 (Triple.getArch() == llvm::Triple::x86_64 || 1315 Triple.getArch() == llvm::Triple::arm)); 1316} 1317 1318/// addExceptionArgs - Adds exception related arguments to the driver command 1319/// arguments. There's a master flag, -fexceptions and also language specific 1320/// flags to enable/disable C++ and Objective-C exceptions. 1321/// This makes it possible to for example disable C++ exceptions but enable 1322/// Objective-C exceptions. 1323static void addExceptionArgs(const ArgList &Args, types::ID InputType, 1324 const llvm::Triple &Triple, 1325 bool KernelOrKext, 1326 const ObjCRuntime &objcRuntime, 1327 ArgStringList &CmdArgs) { 1328 if (KernelOrKext) { 1329 // -mkernel and -fapple-kext imply no exceptions, so claim exception related 1330 // arguments now to avoid warnings about unused arguments. 1331 Args.ClaimAllArgs(options::OPT_fexceptions); 1332 Args.ClaimAllArgs(options::OPT_fno_exceptions); 1333 Args.ClaimAllArgs(options::OPT_fobjc_exceptions); 1334 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions); 1335 Args.ClaimAllArgs(options::OPT_fcxx_exceptions); 1336 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions); 1337 return; 1338 } 1339 1340 // Exceptions are enabled by default. 1341 bool ExceptionsEnabled = true; 1342 1343 // This keeps track of whether exceptions were explicitly turned on or off. 1344 bool DidHaveExplicitExceptionFlag = false; 1345 1346 if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 1347 options::OPT_fno_exceptions)) { 1348 if (A->getOption().matches(options::OPT_fexceptions)) 1349 ExceptionsEnabled = true; 1350 else 1351 ExceptionsEnabled = false; 1352 1353 DidHaveExplicitExceptionFlag = true; 1354 } 1355 1356 bool ShouldUseExceptionTables = false; 1357 1358 // Exception tables and cleanups can be enabled with -fexceptions even if the 1359 // language itself doesn't support exceptions. 1360 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag) 1361 ShouldUseExceptionTables = true; 1362 1363 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This 1364 // is not necessarily sensible, but follows GCC. 1365 if (types::isObjC(InputType) && 1366 Args.hasFlag(options::OPT_fobjc_exceptions, 1367 options::OPT_fno_objc_exceptions, 1368 true)) { 1369 CmdArgs.push_back("-fobjc-exceptions"); 1370 1371 ShouldUseExceptionTables |= 1372 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple); 1373 } 1374 1375 if (types::isCXX(InputType)) { 1376 bool CXXExceptionsEnabled = ExceptionsEnabled; 1377 1378 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions, 1379 options::OPT_fno_cxx_exceptions, 1380 options::OPT_fexceptions, 1381 options::OPT_fno_exceptions)) { 1382 if (A->getOption().matches(options::OPT_fcxx_exceptions)) 1383 CXXExceptionsEnabled = true; 1384 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions)) 1385 CXXExceptionsEnabled = false; 1386 } 1387 1388 if (CXXExceptionsEnabled) { 1389 CmdArgs.push_back("-fcxx-exceptions"); 1390 1391 ShouldUseExceptionTables = true; 1392 } 1393 } 1394 1395 if (ShouldUseExceptionTables) 1396 CmdArgs.push_back("-fexceptions"); 1397} 1398 1399static bool ShouldDisableCFI(const ArgList &Args, 1400 const ToolChain &TC) { 1401 bool Default = true; 1402 if (TC.getTriple().isOSDarwin()) { 1403 // The native darwin assembler doesn't support cfi directives, so 1404 // we disable them if we think the .s file will be passed to it. 1405 Default = Args.hasFlag(options::OPT_integrated_as, 1406 options::OPT_no_integrated_as, 1407 TC.IsIntegratedAssemblerDefault()); 1408 } 1409 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm, 1410 options::OPT_fno_dwarf2_cfi_asm, 1411 Default); 1412} 1413 1414static bool ShouldDisableDwarfDirectory(const ArgList &Args, 1415 const ToolChain &TC) { 1416 bool IsIADefault = TC.IsIntegratedAssemblerDefault(); 1417 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as, 1418 options::OPT_no_integrated_as, 1419 IsIADefault); 1420 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm, 1421 options::OPT_fno_dwarf_directory_asm, 1422 UseIntegratedAs); 1423 return !UseDwarfDirectory; 1424} 1425 1426/// \brief Check whether the given input tree contains any compilation actions. 1427static bool ContainsCompileAction(const Action *A) { 1428 if (isa<CompileJobAction>(A)) 1429 return true; 1430 1431 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 1432 if (ContainsCompileAction(*it)) 1433 return true; 1434 1435 return false; 1436} 1437 1438/// \brief Check if -relax-all should be passed to the internal assembler. 1439/// This is done by default when compiling non-assembler source with -O0. 1440static bool UseRelaxAll(Compilation &C, const ArgList &Args) { 1441 bool RelaxDefault = true; 1442 1443 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1444 RelaxDefault = A->getOption().matches(options::OPT_O0); 1445 1446 if (RelaxDefault) { 1447 RelaxDefault = false; 1448 for (ActionList::const_iterator it = C.getActions().begin(), 1449 ie = C.getActions().end(); it != ie; ++it) { 1450 if (ContainsCompileAction(*it)) { 1451 RelaxDefault = true; 1452 break; 1453 } 1454 } 1455 } 1456 1457 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, 1458 RelaxDefault); 1459} 1460 1461SanitizerArgs::SanitizerArgs(const Driver &D, const ArgList &Args) { 1462 Kind = 0; 1463 1464 const Arg *AsanArg, *TsanArg, *UbsanArg; 1465 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) { 1466 unsigned Add = 0, Remove = 0; 1467 const char *DeprecatedReplacement = 0; 1468 if ((*I)->getOption().matches(options::OPT_faddress_sanitizer)) { 1469 Add = Address; 1470 DeprecatedReplacement = "-fsanitize=address"; 1471 } else if ((*I)->getOption().matches(options::OPT_fno_address_sanitizer)) { 1472 Remove = Address; 1473 DeprecatedReplacement = "-fno-sanitize=address"; 1474 } else if ((*I)->getOption().matches(options::OPT_fthread_sanitizer)) { 1475 Add = Thread; 1476 DeprecatedReplacement = "-fsanitize=thread"; 1477 } else if ((*I)->getOption().matches(options::OPT_fno_thread_sanitizer)) { 1478 Remove = Thread; 1479 DeprecatedReplacement = "-fno-sanitize=thread"; 1480 } else if ((*I)->getOption().matches(options::OPT_fcatch_undefined_behavior)) { 1481 Add = Undefined; 1482 DeprecatedReplacement = "-fsanitize=undefined"; 1483 } else if ((*I)->getOption().matches(options::OPT_fsanitize_EQ)) { 1484 Add = parse(D, *I); 1485 } else if ((*I)->getOption().matches(options::OPT_fno_sanitize_EQ)) { 1486 Remove = parse(D, *I); 1487 } else { 1488 continue; 1489 } 1490 1491 (*I)->claim(); 1492 1493 Kind |= Add; 1494 Kind &= ~Remove; 1495 1496 if (Add & NeedsAsanRt) AsanArg = *I; 1497 if (Add & NeedsTsanRt) TsanArg = *I; 1498 if (Add & NeedsUbsanRt) UbsanArg = *I; 1499 1500 // If this is a deprecated synonym, produce a warning directing users 1501 // towards the new spelling. 1502 if (DeprecatedReplacement) 1503 D.Diag(diag::warn_drv_deprecated_arg) 1504 << (*I)->getAsString(Args) << DeprecatedReplacement; 1505 } 1506 1507 // Only one runtime library can be used at once. 1508 // FIXME: Allow Ubsan to be combined with the other two. 1509 bool NeedsAsan = needsAsanRt(); 1510 bool NeedsTsan = needsTsanRt(); 1511 bool NeedsUbsan = needsUbsanRt(); 1512 if (NeedsAsan + NeedsTsan + NeedsUbsan > 1) 1513 D.Diag(diag::err_drv_argument_not_allowed_with) 1514 << describeSanitizeArg(Args, NeedsAsan ? AsanArg : TsanArg, 1515 NeedsAsan ? NeedsAsanRt : NeedsTsanRt) 1516 << describeSanitizeArg(Args, NeedsUbsan ? UbsanArg : TsanArg, 1517 NeedsUbsan ? NeedsUbsanRt : NeedsTsanRt); 1518} 1519 1520/// If AddressSanitizer is enabled, add appropriate linker flags (Linux). 1521/// This needs to be called before we add the C run-time (malloc, etc). 1522static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args, 1523 ArgStringList &CmdArgs) { 1524 if(TC.getTriple().getEnvironment() == llvm::Triple::Android) { 1525 if (!Args.hasArg(options::OPT_shared)) { 1526 if (!Args.hasArg(options::OPT_pie)) 1527 TC.getDriver().Diag(diag::err_drv_asan_android_requires_pie); 1528 } 1529 1530 SmallString<128> LibAsan(TC.getDriver().ResourceDir); 1531 llvm::sys::path::append(LibAsan, "lib", "linux", 1532 (Twine("libclang_rt.asan-") + 1533 TC.getArchName() + "-android.so")); 1534 CmdArgs.push_back(Args.MakeArgString(LibAsan)); 1535 } else { 1536 if (!Args.hasArg(options::OPT_shared)) { 1537 // LibAsan is "libclang_rt.asan-<ArchName>.a" in the Linux library 1538 // resource directory. 1539 SmallString<128> LibAsan(TC.getDriver().ResourceDir); 1540 llvm::sys::path::append(LibAsan, "lib", "linux", 1541 (Twine("libclang_rt.asan-") + 1542 TC.getArchName() + ".a")); 1543 CmdArgs.push_back(Args.MakeArgString(LibAsan)); 1544 CmdArgs.push_back("-lpthread"); 1545 CmdArgs.push_back("-ldl"); 1546 CmdArgs.push_back("-export-dynamic"); 1547 } 1548 } 1549} 1550 1551/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux). 1552/// This needs to be called before we add the C run-time (malloc, etc). 1553static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args, 1554 ArgStringList &CmdArgs) { 1555 if (!Args.hasArg(options::OPT_shared)) { 1556 // LibTsan is "libclang_rt.tsan-<ArchName>.a" in the Linux library 1557 // resource directory. 1558 SmallString<128> LibTsan(TC.getDriver().ResourceDir); 1559 llvm::sys::path::append(LibTsan, "lib", "linux", 1560 (Twine("libclang_rt.tsan-") + 1561 TC.getArchName() + ".a")); 1562 CmdArgs.push_back(Args.MakeArgString(LibTsan)); 1563 CmdArgs.push_back("-lpthread"); 1564 CmdArgs.push_back("-ldl"); 1565 CmdArgs.push_back("-export-dynamic"); 1566 } 1567} 1568 1569/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags 1570/// (Linux). 1571static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args, 1572 ArgStringList &CmdArgs) { 1573 if (!Args.hasArg(options::OPT_shared)) { 1574 // LibUbsan is "libclang_rt.ubsan-<ArchName>.a" in the Linux library 1575 // resource directory. 1576 SmallString<128> LibUbsan(TC.getDriver().ResourceDir); 1577 llvm::sys::path::append(LibUbsan, "lib", "linux", 1578 (Twine("libclang_rt.ubsan-") + 1579 TC.getArchName() + ".a")); 1580 CmdArgs.push_back(Args.MakeArgString(LibUbsan)); 1581 CmdArgs.push_back("-lpthread"); 1582 } 1583} 1584 1585static bool shouldUseFramePointer(const ArgList &Args, 1586 const llvm::Triple &Triple) { 1587 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer, 1588 options::OPT_fomit_frame_pointer)) 1589 return A->getOption().matches(options::OPT_fno_omit_frame_pointer); 1590 1591 // Don't use a frame pointer on linux x86 and x86_64 if optimizing. 1592 if ((Triple.getArch() == llvm::Triple::x86_64 || 1593 Triple.getArch() == llvm::Triple::x86) && 1594 Triple.getOS() == llvm::Triple::Linux) { 1595 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1596 if (!A->getOption().matches(options::OPT_O0)) 1597 return false; 1598 } 1599 1600 return true; 1601} 1602 1603void Clang::ConstructJob(Compilation &C, const JobAction &JA, 1604 const InputInfo &Output, 1605 const InputInfoList &Inputs, 1606 const ArgList &Args, 1607 const char *LinkingOutput) const { 1608 bool KernelOrKext = Args.hasArg(options::OPT_mkernel, 1609 options::OPT_fapple_kext); 1610 const Driver &D = getToolChain().getDriver(); 1611 ArgStringList CmdArgs; 1612 1613 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 1614 1615 // Invoke ourselves in -cc1 mode. 1616 // 1617 // FIXME: Implement custom jobs for internal actions. 1618 CmdArgs.push_back("-cc1"); 1619 1620 // Add the "effective" target triple. 1621 CmdArgs.push_back("-triple"); 1622 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 1623 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 1624 1625 // Select the appropriate action. 1626 RewriteKind rewriteKind = RK_None; 1627 1628 if (isa<AnalyzeJobAction>(JA)) { 1629 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 1630 CmdArgs.push_back("-analyze"); 1631 } else if (isa<MigrateJobAction>(JA)) { 1632 CmdArgs.push_back("-migrate"); 1633 } else if (isa<PreprocessJobAction>(JA)) { 1634 if (Output.getType() == types::TY_Dependencies) 1635 CmdArgs.push_back("-Eonly"); 1636 else 1637 CmdArgs.push_back("-E"); 1638 } else if (isa<AssembleJobAction>(JA)) { 1639 CmdArgs.push_back("-emit-obj"); 1640 1641 if (UseRelaxAll(C, Args)) 1642 CmdArgs.push_back("-mrelax-all"); 1643 1644 // When using an integrated assembler, translate -Wa, and -Xassembler 1645 // options. 1646 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA, 1647 options::OPT_Xassembler), 1648 ie = Args.filtered_end(); it != ie; ++it) { 1649 const Arg *A = *it; 1650 A->claim(); 1651 1652 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 1653 StringRef Value = A->getValue(i); 1654 1655 if (Value == "-force_cpusubtype_ALL") { 1656 // Do nothing, this is the default and we don't support anything else. 1657 } else if (Value == "-L") { 1658 CmdArgs.push_back("-msave-temp-labels"); 1659 } else if (Value == "--fatal-warnings") { 1660 CmdArgs.push_back("-mllvm"); 1661 CmdArgs.push_back("-fatal-assembler-warnings"); 1662 } else if (Value == "--noexecstack") { 1663 CmdArgs.push_back("-mnoexecstack"); 1664 } else { 1665 D.Diag(diag::err_drv_unsupported_option_argument) 1666 << A->getOption().getName() << Value; 1667 } 1668 } 1669 } 1670 1671 // Also ignore explicit -force_cpusubtype_ALL option. 1672 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 1673 } else if (isa<PrecompileJobAction>(JA)) { 1674 // Use PCH if the user requested it. 1675 bool UsePCH = D.CCCUsePCH; 1676 1677 if (JA.getType() == types::TY_Nothing) 1678 CmdArgs.push_back("-fsyntax-only"); 1679 else if (UsePCH) 1680 CmdArgs.push_back("-emit-pch"); 1681 else 1682 CmdArgs.push_back("-emit-pth"); 1683 } else { 1684 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 1685 1686 if (JA.getType() == types::TY_Nothing) { 1687 CmdArgs.push_back("-fsyntax-only"); 1688 } else if (JA.getType() == types::TY_LLVM_IR || 1689 JA.getType() == types::TY_LTO_IR) { 1690 CmdArgs.push_back("-emit-llvm"); 1691 } else if (JA.getType() == types::TY_LLVM_BC || 1692 JA.getType() == types::TY_LTO_BC) { 1693 CmdArgs.push_back("-emit-llvm-bc"); 1694 } else if (JA.getType() == types::TY_PP_Asm) { 1695 CmdArgs.push_back("-S"); 1696 } else if (JA.getType() == types::TY_AST) { 1697 CmdArgs.push_back("-emit-pch"); 1698 } else if (JA.getType() == types::TY_RewrittenObjC) { 1699 CmdArgs.push_back("-rewrite-objc"); 1700 rewriteKind = RK_NonFragile; 1701 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) { 1702 CmdArgs.push_back("-rewrite-objc"); 1703 rewriteKind = RK_Fragile; 1704 } else { 1705 assert(JA.getType() == types::TY_PP_Asm && 1706 "Unexpected output type!"); 1707 } 1708 } 1709 1710 // The make clang go fast button. 1711 CmdArgs.push_back("-disable-free"); 1712 1713 // Disable the verification pass in -asserts builds. 1714#ifdef NDEBUG 1715 CmdArgs.push_back("-disable-llvm-verifier"); 1716#endif 1717 1718 // Set the main file name, so that debug info works even with 1719 // -save-temps. 1720 CmdArgs.push_back("-main-file-name"); 1721 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 1722 1723 // Some flags which affect the language (via preprocessor 1724 // defines). See darwin::CC1::AddCPPArgs. 1725 if (Args.hasArg(options::OPT_static)) 1726 CmdArgs.push_back("-static-define"); 1727 1728 if (isa<AnalyzeJobAction>(JA)) { 1729 // Enable region store model by default. 1730 CmdArgs.push_back("-analyzer-store=region"); 1731 1732 // Treat blocks as analysis entry points. 1733 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 1734 1735 CmdArgs.push_back("-analyzer-eagerly-assume"); 1736 1737 // Add default argument set. 1738 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 1739 CmdArgs.push_back("-analyzer-checker=core"); 1740 1741 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32) 1742 CmdArgs.push_back("-analyzer-checker=unix"); 1743 1744 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple) 1745 CmdArgs.push_back("-analyzer-checker=osx"); 1746 1747 CmdArgs.push_back("-analyzer-checker=deadcode"); 1748 1749 // Enable the following experimental checkers for testing. 1750 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn"); 1751 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw"); 1752 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets"); 1753 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); 1754 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp"); 1755 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork"); 1756 } 1757 1758 // Set the output format. The default is plist, for (lame) historical 1759 // reasons. 1760 CmdArgs.push_back("-analyzer-output"); 1761 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 1762 CmdArgs.push_back(A->getValue()); 1763 else 1764 CmdArgs.push_back("plist"); 1765 1766 // Disable the presentation of standard compiler warnings when 1767 // using --analyze. We only want to show static analyzer diagnostics 1768 // or frontend errors. 1769 CmdArgs.push_back("-w"); 1770 1771 // Add -Xanalyzer arguments when running as analyzer. 1772 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 1773 } 1774 1775 CheckCodeGenerationOptions(D, Args); 1776 1777 // For the PIC and PIE flag options, this logic is different from the legacy 1778 // logic in very old versions of GCC, as that logic was just a bug no one had 1779 // ever fixed. This logic is both more rational and consistent with GCC's new 1780 // logic now that the bugs are fixed. The last argument relating to either 1781 // PIC or PIE wins, and no other argument is used. If the last argument is 1782 // any flavor of the '-fno-...' arguments, both PIC and PIE are disabled. Any 1783 // PIE option implicitly enables PIC at the same level. 1784 bool PIE = false; 1785 bool PIC = getToolChain().isPICDefault(); 1786 bool IsPICLevelTwo = PIC; 1787 if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 1788 options::OPT_fpic, options::OPT_fno_pic, 1789 options::OPT_fPIE, options::OPT_fno_PIE, 1790 options::OPT_fpie, options::OPT_fno_pie)) { 1791 Option O = A->getOption(); 1792 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) || 1793 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) { 1794 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie); 1795 PIC = PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic); 1796 IsPICLevelTwo = O.matches(options::OPT_fPIE) || 1797 O.matches(options::OPT_fPIC); 1798 } else { 1799 PIE = PIC = false; 1800 } 1801 } 1802 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness 1803 // is forced, then neither PIC nor PIE flags will have no effect. 1804 if (getToolChain().isPICDefaultForced()) { 1805 PIE = false; 1806 PIC = getToolChain().isPICDefault(); 1807 IsPICLevelTwo = PIC; 1808 } 1809 1810 // Inroduce a Darwin-specific hack. If the default is PIC but the flags 1811 // specified while enabling PIC enabled level 1 PIC, just force it back to 1812 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my 1813 // informal testing). 1814 if (PIC && getToolChain().getTriple().isOSDarwin()) 1815 IsPICLevelTwo |= getToolChain().isPICDefault(); 1816 1817 // Note that these flags are trump-cards. Regardless of the order w.r.t. the 1818 // PIC or PIE options above, if these show up, PIC is disabled. 1819 llvm::Triple Triple(TripleStr); 1820 if ((Args.hasArg(options::OPT_mkernel) || 1821 Args.hasArg(options::OPT_fapple_kext)) && 1822 (Triple.getOS() != llvm::Triple::IOS || 1823 Triple.isOSVersionLT(6))) 1824 PIC = PIE = false; 1825 if (Args.hasArg(options::OPT_static)) 1826 PIC = PIE = false; 1827 1828 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) { 1829 // This is a very special mode. It trumps the other modes, almost no one 1830 // uses it, and it isn't even valid on any OS but Darwin. 1831 if (!getToolChain().getTriple().isOSDarwin()) 1832 D.Diag(diag::err_drv_unsupported_opt_for_target) 1833 << A->getSpelling() << getToolChain().getTriple().str(); 1834 1835 // FIXME: Warn when this flag trumps some other PIC or PIE flag. 1836 1837 CmdArgs.push_back("-mrelocation-model"); 1838 CmdArgs.push_back("dynamic-no-pic"); 1839 1840 // Only a forced PIC mode can cause the actual compile to have PIC defines 1841 // etc., no flags are sufficient. This behavior was selected to closely 1842 // match that of llvm-gcc and Apple GCC before that. 1843 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) { 1844 CmdArgs.push_back("-pic-level"); 1845 CmdArgs.push_back("2"); 1846 } 1847 } else { 1848 // Currently, LLVM only knows about PIC vs. static; the PIE differences are 1849 // handled in Clang's IRGen by the -pie-level flag. 1850 CmdArgs.push_back("-mrelocation-model"); 1851 CmdArgs.push_back(PIC ? "pic" : "static"); 1852 1853 if (PIC) { 1854 CmdArgs.push_back("-pic-level"); 1855 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1"); 1856 if (PIE) { 1857 CmdArgs.push_back("-pie-level"); 1858 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1"); 1859 } 1860 } 1861 } 1862 1863 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 1864 options::OPT_fno_merge_all_constants)) 1865 CmdArgs.push_back("-fno-merge-all-constants"); 1866 1867 // LLVM Code Generator Options. 1868 1869 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 1870 CmdArgs.push_back("-mregparm"); 1871 CmdArgs.push_back(A->getValue()); 1872 } 1873 1874 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) 1875 CmdArgs.push_back("-mrtd"); 1876 1877 if (shouldUseFramePointer(Args, getToolChain().getTriple())) 1878 CmdArgs.push_back("-mdisable-fp-elim"); 1879 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 1880 options::OPT_fno_zero_initialized_in_bss)) 1881 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 1882 if (!Args.hasFlag(options::OPT_fstrict_aliasing, 1883 options::OPT_fno_strict_aliasing, 1884 getToolChain().IsStrictAliasingDefault())) 1885 CmdArgs.push_back("-relaxed-aliasing"); 1886 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums, 1887 false)) 1888 CmdArgs.push_back("-fstrict-enums"); 1889 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls, 1890 options::OPT_fno_optimize_sibling_calls)) 1891 CmdArgs.push_back("-mdisable-tail-calls"); 1892 1893 // Handle various floating point optimization flags, mapping them to the 1894 // appropriate LLVM code generation flags. The pattern for all of these is to 1895 // default off the codegen optimizations, and if any flag enables them and no 1896 // flag disables them after the flag enabling them, enable the codegen 1897 // optimization. This is complicated by several "umbrella" flags. 1898 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1899 options::OPT_fno_fast_math, 1900 options::OPT_ffinite_math_only, 1901 options::OPT_fno_finite_math_only, 1902 options::OPT_fhonor_infinities, 1903 options::OPT_fno_honor_infinities)) 1904 if (A->getOption().getID() != options::OPT_fno_fast_math && 1905 A->getOption().getID() != options::OPT_fno_finite_math_only && 1906 A->getOption().getID() != options::OPT_fhonor_infinities) 1907 CmdArgs.push_back("-menable-no-infs"); 1908 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1909 options::OPT_fno_fast_math, 1910 options::OPT_ffinite_math_only, 1911 options::OPT_fno_finite_math_only, 1912 options::OPT_fhonor_nans, 1913 options::OPT_fno_honor_nans)) 1914 if (A->getOption().getID() != options::OPT_fno_fast_math && 1915 A->getOption().getID() != options::OPT_fno_finite_math_only && 1916 A->getOption().getID() != options::OPT_fhonor_nans) 1917 CmdArgs.push_back("-menable-no-nans"); 1918 1919 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. 1920 bool MathErrno = getToolChain().IsMathErrnoDefault(); 1921 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1922 options::OPT_fno_fast_math, 1923 options::OPT_fmath_errno, 1924 options::OPT_fno_math_errno)) 1925 MathErrno = A->getOption().getID() == options::OPT_fmath_errno; 1926 if (MathErrno) 1927 CmdArgs.push_back("-fmath-errno"); 1928 1929 // There are several flags which require disabling very specific 1930 // optimizations. Any of these being disabled forces us to turn off the 1931 // entire set of LLVM optimizations, so collect them through all the flag 1932 // madness. 1933 bool AssociativeMath = false; 1934 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1935 options::OPT_fno_fast_math, 1936 options::OPT_funsafe_math_optimizations, 1937 options::OPT_fno_unsafe_math_optimizations, 1938 options::OPT_fassociative_math, 1939 options::OPT_fno_associative_math)) 1940 if (A->getOption().getID() != options::OPT_fno_fast_math && 1941 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 1942 A->getOption().getID() != options::OPT_fno_associative_math) 1943 AssociativeMath = true; 1944 bool ReciprocalMath = false; 1945 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1946 options::OPT_fno_fast_math, 1947 options::OPT_funsafe_math_optimizations, 1948 options::OPT_fno_unsafe_math_optimizations, 1949 options::OPT_freciprocal_math, 1950 options::OPT_fno_reciprocal_math)) 1951 if (A->getOption().getID() != options::OPT_fno_fast_math && 1952 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 1953 A->getOption().getID() != options::OPT_fno_reciprocal_math) 1954 ReciprocalMath = true; 1955 bool SignedZeros = true; 1956 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1957 options::OPT_fno_fast_math, 1958 options::OPT_funsafe_math_optimizations, 1959 options::OPT_fno_unsafe_math_optimizations, 1960 options::OPT_fsigned_zeros, 1961 options::OPT_fno_signed_zeros)) 1962 if (A->getOption().getID() != options::OPT_fno_fast_math && 1963 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 1964 A->getOption().getID() != options::OPT_fsigned_zeros) 1965 SignedZeros = false; 1966 bool TrappingMath = true; 1967 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1968 options::OPT_fno_fast_math, 1969 options::OPT_funsafe_math_optimizations, 1970 options::OPT_fno_unsafe_math_optimizations, 1971 options::OPT_ftrapping_math, 1972 options::OPT_fno_trapping_math)) 1973 if (A->getOption().getID() != options::OPT_fno_fast_math && 1974 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 1975 A->getOption().getID() != options::OPT_ftrapping_math) 1976 TrappingMath = false; 1977 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros && 1978 !TrappingMath) 1979 CmdArgs.push_back("-menable-unsafe-fp-math"); 1980 1981 1982 // Validate and pass through -fp-contract option. 1983 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, 1984 options::OPT_fno_fast_math, 1985 options::OPT_ffp_contract)) { 1986 if (A->getOption().getID() == options::OPT_ffp_contract) { 1987 StringRef Val = A->getValue(); 1988 if (Val == "fast" || Val == "on" || Val == "off") { 1989 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val)); 1990 } else { 1991 D.Diag(diag::err_drv_unsupported_option_argument) 1992 << A->getOption().getName() << Val; 1993 } 1994 } else if (A->getOption().getID() == options::OPT_ffast_math) { 1995 // If fast-math is set then set the fp-contract mode to fast. 1996 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast")); 1997 } 1998 } 1999 2000 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags, 2001 // and if we find them, tell the frontend to provide the appropriate 2002 // preprocessor macros. This is distinct from enabling any optimizations as 2003 // these options induce language changes which must survive serialization 2004 // and deserialization, etc. 2005 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math)) 2006 if (A->getOption().matches(options::OPT_ffast_math)) 2007 CmdArgs.push_back("-ffast-math"); 2008 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math)) 2009 if (A->getOption().matches(options::OPT_ffinite_math_only)) 2010 CmdArgs.push_back("-ffinite-math-only"); 2011 2012 // Decide whether to use verbose asm. Verbose assembly is the default on 2013 // toolchains which have the integrated assembler on by default. 2014 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault(); 2015 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 2016 IsVerboseAsmDefault) || 2017 Args.hasArg(options::OPT_dA)) 2018 CmdArgs.push_back("-masm-verbose"); 2019 2020 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 2021 CmdArgs.push_back("-mdebug-pass"); 2022 CmdArgs.push_back("Structure"); 2023 } 2024 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 2025 CmdArgs.push_back("-mdebug-pass"); 2026 CmdArgs.push_back("Arguments"); 2027 } 2028 2029 // Enable -mconstructor-aliases except on darwin, where we have to 2030 // work around a linker bug; see <rdar://problem/7651567>. 2031 if (!getToolChain().getTriple().isOSDarwin()) 2032 CmdArgs.push_back("-mconstructor-aliases"); 2033 2034 // Darwin's kernel doesn't support guard variables; just die if we 2035 // try to use them. 2036 if (KernelOrKext && getToolChain().getTriple().isOSDarwin()) 2037 CmdArgs.push_back("-fforbid-guard-variables"); 2038 2039 if (Args.hasArg(options::OPT_mms_bitfields)) { 2040 CmdArgs.push_back("-mms-bitfields"); 2041 } 2042 2043 // This is a coarse approximation of what llvm-gcc actually does, both 2044 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 2045 // complicated ways. 2046 bool AsynchronousUnwindTables = 2047 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 2048 options::OPT_fno_asynchronous_unwind_tables, 2049 getToolChain().IsUnwindTablesDefault() && 2050 !KernelOrKext); 2051 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 2052 AsynchronousUnwindTables)) 2053 CmdArgs.push_back("-munwind-tables"); 2054 2055 getToolChain().addClangTargetOptions(CmdArgs); 2056 2057 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 2058 CmdArgs.push_back("-mlimit-float-precision"); 2059 CmdArgs.push_back(A->getValue()); 2060 } 2061 2062 // FIXME: Handle -mtune=. 2063 (void) Args.hasArg(options::OPT_mtune_EQ); 2064 2065 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 2066 CmdArgs.push_back("-mcode-model"); 2067 CmdArgs.push_back(A->getValue()); 2068 } 2069 2070 // Add target specific cpu and features flags. 2071 switch(getToolChain().getTriple().getArch()) { 2072 default: 2073 break; 2074 2075 case llvm::Triple::arm: 2076 case llvm::Triple::thumb: 2077 AddARMTargetArgs(Args, CmdArgs, KernelOrKext); 2078 break; 2079 2080 case llvm::Triple::mips: 2081 case llvm::Triple::mipsel: 2082 case llvm::Triple::mips64: 2083 case llvm::Triple::mips64el: 2084 AddMIPSTargetArgs(Args, CmdArgs); 2085 break; 2086 2087 case llvm::Triple::ppc: 2088 case llvm::Triple::ppc64: 2089 AddPPCTargetArgs(Args, CmdArgs); 2090 break; 2091 2092 case llvm::Triple::sparc: 2093 AddSparcTargetArgs(Args, CmdArgs); 2094 break; 2095 2096 case llvm::Triple::x86: 2097 case llvm::Triple::x86_64: 2098 AddX86TargetArgs(Args, CmdArgs); 2099 break; 2100 2101 case llvm::Triple::hexagon: 2102 AddHexagonTargetArgs(Args, CmdArgs); 2103 break; 2104 } 2105 2106 2107 2108 // Pass the linker version in use. 2109 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 2110 CmdArgs.push_back("-target-linker-version"); 2111 CmdArgs.push_back(A->getValue()); 2112 } 2113 2114 // -mno-omit-leaf-frame-pointer is the default on Darwin. 2115 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer, 2116 options::OPT_mno_omit_leaf_frame_pointer, 2117 !getToolChain().getTriple().isOSDarwin())) 2118 CmdArgs.push_back("-momit-leaf-frame-pointer"); 2119 2120 // Explicitly error on some things we know we don't support and can't just 2121 // ignore. 2122 types::ID InputType = Inputs[0].getType(); 2123 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 2124 Arg *Unsupported; 2125 if (types::isCXX(InputType) && 2126 getToolChain().getTriple().isOSDarwin() && 2127 getToolChain().getTriple().getArch() == llvm::Triple::x86) { 2128 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || 2129 (Unsupported = Args.getLastArg(options::OPT_mkernel))) 2130 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 2131 << Unsupported->getOption().getName(); 2132 } 2133 } 2134 2135 Args.AddAllArgs(CmdArgs, options::OPT_v); 2136 Args.AddLastArg(CmdArgs, options::OPT_H); 2137 if (D.CCPrintHeaders && !D.CCGenDiagnostics) { 2138 CmdArgs.push_back("-header-include-file"); 2139 CmdArgs.push_back(D.CCPrintHeadersFilename ? 2140 D.CCPrintHeadersFilename : "-"); 2141 } 2142 Args.AddLastArg(CmdArgs, options::OPT_P); 2143 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 2144 2145 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { 2146 CmdArgs.push_back("-diagnostic-log-file"); 2147 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? 2148 D.CCLogDiagnosticsFilename : "-"); 2149 } 2150 2151 // Use the last option from "-g" group. "-gline-tables-only" is 2152 // preserved, all other debug options are substituted with "-g". 2153 Args.ClaimAllArgs(options::OPT_g_Group); 2154 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) { 2155 if (A->getOption().matches(options::OPT_gline_tables_only)) { 2156 CmdArgs.push_back("-gline-tables-only"); 2157 } else if (!A->getOption().matches(options::OPT_g0) && 2158 !A->getOption().matches(options::OPT_ggdb0)) { 2159 CmdArgs.push_back("-g"); 2160 } 2161 } 2162 2163 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now. 2164 Args.ClaimAllArgs(options::OPT_g_flags_Group); 2165 if (Args.hasArg(options::OPT_gcolumn_info)) 2166 CmdArgs.push_back("-dwarf-column-info"); 2167 2168 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections); 2169 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections); 2170 2171 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions); 2172 2173 if (Args.hasArg(options::OPT_ftest_coverage) || 2174 Args.hasArg(options::OPT_coverage)) 2175 CmdArgs.push_back("-femit-coverage-notes"); 2176 if (Args.hasArg(options::OPT_fprofile_arcs) || 2177 Args.hasArg(options::OPT_coverage)) 2178 CmdArgs.push_back("-femit-coverage-data"); 2179 2180 if (C.getArgs().hasArg(options::OPT_c) || 2181 C.getArgs().hasArg(options::OPT_S)) { 2182 if (Output.isFilename()) { 2183 CmdArgs.push_back("-coverage-file"); 2184 SmallString<128> absFilename(Output.getFilename()); 2185 llvm::sys::fs::make_absolute(absFilename); 2186 CmdArgs.push_back(Args.MakeArgString(absFilename)); 2187 } 2188 } 2189 2190 // Pass options for controlling the default header search paths. 2191 if (Args.hasArg(options::OPT_nostdinc)) { 2192 CmdArgs.push_back("-nostdsysteminc"); 2193 CmdArgs.push_back("-nobuiltininc"); 2194 } else { 2195 if (Args.hasArg(options::OPT_nostdlibinc)) 2196 CmdArgs.push_back("-nostdsysteminc"); 2197 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 2198 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 2199 } 2200 2201 // Pass the path to compiler resource files. 2202 CmdArgs.push_back("-resource-dir"); 2203 CmdArgs.push_back(D.ResourceDir.c_str()); 2204 2205 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 2206 2207 bool ARCMTEnabled = false; 2208 if (!Args.hasArg(options::OPT_fno_objc_arc)) { 2209 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check, 2210 options::OPT_ccc_arcmt_modify, 2211 options::OPT_ccc_arcmt_migrate)) { 2212 ARCMTEnabled = true; 2213 switch (A->getOption().getID()) { 2214 default: 2215 llvm_unreachable("missed a case"); 2216 case options::OPT_ccc_arcmt_check: 2217 CmdArgs.push_back("-arcmt-check"); 2218 break; 2219 case options::OPT_ccc_arcmt_modify: 2220 CmdArgs.push_back("-arcmt-modify"); 2221 break; 2222 case options::OPT_ccc_arcmt_migrate: 2223 CmdArgs.push_back("-arcmt-migrate"); 2224 CmdArgs.push_back("-mt-migrate-directory"); 2225 CmdArgs.push_back(A->getValue()); 2226 2227 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output); 2228 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors); 2229 break; 2230 } 2231 } 2232 } 2233 2234 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) { 2235 if (ARCMTEnabled) { 2236 D.Diag(diag::err_drv_argument_not_allowed_with) 2237 << A->getAsString(Args) << "-ccc-arcmt-migrate"; 2238 } 2239 CmdArgs.push_back("-mt-migrate-directory"); 2240 CmdArgs.push_back(A->getValue()); 2241 2242 if (!Args.hasArg(options::OPT_objcmt_migrate_literals, 2243 options::OPT_objcmt_migrate_subscripting)) { 2244 // None specified, means enable them all. 2245 CmdArgs.push_back("-objcmt-migrate-literals"); 2246 CmdArgs.push_back("-objcmt-migrate-subscripting"); 2247 } else { 2248 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 2249 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 2250 } 2251 } 2252 2253 // Add preprocessing options like -I, -D, etc. if we are using the 2254 // preprocessor. 2255 // 2256 // FIXME: Support -fpreprocessed 2257 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 2258 AddPreprocessingOptions(C, D, Args, CmdArgs, Output, Inputs); 2259 2260 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes 2261 // that "The compiler can only warn and ignore the option if not recognized". 2262 // When building with ccache, it will pass -D options to clang even on 2263 // preprocessed inputs and configure concludes that -fPIC is not supported. 2264 Args.ClaimAllArgs(options::OPT_D); 2265 2266 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 2267 // others. 2268 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 2269 if (A->getOption().matches(options::OPT_O4)) 2270 CmdArgs.push_back("-O3"); 2271 else if (A->getOption().matches(options::OPT_O) && 2272 A->getValue()[0] == '\0') 2273 CmdArgs.push_back("-O2"); 2274 else 2275 A->render(Args, CmdArgs); 2276 } 2277 2278 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 2279 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false)) 2280 CmdArgs.push_back("-pedantic"); 2281 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 2282 Args.AddLastArg(CmdArgs, options::OPT_w); 2283 2284 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 2285 // (-ansi is equivalent to -std=c89). 2286 // 2287 // If a std is supplied, only add -trigraphs if it follows the 2288 // option. 2289 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2290 if (Std->getOption().matches(options::OPT_ansi)) 2291 if (types::isCXX(InputType)) 2292 CmdArgs.push_back("-std=c++98"); 2293 else 2294 CmdArgs.push_back("-std=c89"); 2295 else 2296 Std->render(Args, CmdArgs); 2297 2298 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 2299 options::OPT_trigraphs)) 2300 if (A != Std) 2301 A->render(Args, CmdArgs); 2302 } else { 2303 // Honor -std-default. 2304 // 2305 // FIXME: Clang doesn't correctly handle -std= when the input language 2306 // doesn't match. For the time being just ignore this for C++ inputs; 2307 // eventually we want to do all the standard defaulting here instead of 2308 // splitting it between the driver and clang -cc1. 2309 if (!types::isCXX(InputType)) 2310 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2311 "-std=", /*Joined=*/true); 2312 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32) 2313 CmdArgs.push_back("-std=c++11"); 2314 2315 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 2316 } 2317 2318 // Map the bizarre '-Wwrite-strings' flag to a more sensible 2319 // '-fconst-strings'; this better indicates its actual behavior. 2320 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings, 2321 false)) { 2322 // For perfect compatibility with GCC, we do this even in the presence of 2323 // '-w'. This flag names something other than a warning for GCC. 2324 CmdArgs.push_back("-fconst-strings"); 2325 } 2326 2327 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active 2328 // during C++ compilation, which it is by default. GCC keeps this define even 2329 // in the presence of '-w', match this behavior bug-for-bug. 2330 if (types::isCXX(InputType) && 2331 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated, 2332 true)) { 2333 CmdArgs.push_back("-fdeprecated-macro"); 2334 } 2335 2336 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 2337 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 2338 if (Asm->getOption().matches(options::OPT_fasm)) 2339 CmdArgs.push_back("-fgnu-keywords"); 2340 else 2341 CmdArgs.push_back("-fno-gnu-keywords"); 2342 } 2343 2344 if (ShouldDisableCFI(Args, getToolChain())) 2345 CmdArgs.push_back("-fno-dwarf2-cfi-asm"); 2346 2347 if (ShouldDisableDwarfDirectory(Args, getToolChain())) 2348 CmdArgs.push_back("-fno-dwarf-directory-asm"); 2349 2350 if (const char *pwd = ::getenv("PWD")) { 2351 // GCC also verifies that stat(pwd) and stat(".") have the same inode 2352 // number. Not doing those because stats are slow, but we could. 2353 if (llvm::sys::path::is_absolute(pwd)) { 2354 std::string CompDir = pwd; 2355 CmdArgs.push_back("-fdebug-compilation-dir"); 2356 CmdArgs.push_back(Args.MakeArgString(CompDir)); 2357 } 2358 } 2359 2360 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_, 2361 options::OPT_ftemplate_depth_EQ)) { 2362 CmdArgs.push_back("-ftemplate-depth"); 2363 CmdArgs.push_back(A->getValue()); 2364 } 2365 2366 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) { 2367 CmdArgs.push_back("-fconstexpr-depth"); 2368 CmdArgs.push_back(A->getValue()); 2369 } 2370 2371 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 2372 options::OPT_Wlarge_by_value_copy_def)) { 2373 if (A->getNumValues()) { 2374 StringRef bytes = A->getValue(); 2375 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes)); 2376 } else 2377 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value 2378 } 2379 2380 if (Arg *A = Args.getLastArg(options::OPT_fbounds_checking, 2381 options::OPT_fbounds_checking_EQ)) { 2382 if (A->getNumValues()) { 2383 StringRef val = A->getValue(); 2384 CmdArgs.push_back(Args.MakeArgString("-fbounds-checking=" + val)); 2385 } else 2386 CmdArgs.push_back("-fbounds-checking=1"); 2387 } 2388 2389 if (Args.hasArg(options::OPT_relocatable_pch)) 2390 CmdArgs.push_back("-relocatable-pch"); 2391 2392 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 2393 CmdArgs.push_back("-fconstant-string-class"); 2394 CmdArgs.push_back(A->getValue()); 2395 } 2396 2397 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 2398 CmdArgs.push_back("-ftabstop"); 2399 CmdArgs.push_back(A->getValue()); 2400 } 2401 2402 CmdArgs.push_back("-ferror-limit"); 2403 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 2404 CmdArgs.push_back(A->getValue()); 2405 else 2406 CmdArgs.push_back("19"); 2407 2408 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 2409 CmdArgs.push_back("-fmacro-backtrace-limit"); 2410 CmdArgs.push_back(A->getValue()); 2411 } 2412 2413 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 2414 CmdArgs.push_back("-ftemplate-backtrace-limit"); 2415 CmdArgs.push_back(A->getValue()); 2416 } 2417 2418 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) { 2419 CmdArgs.push_back("-fconstexpr-backtrace-limit"); 2420 CmdArgs.push_back(A->getValue()); 2421 } 2422 2423 // Pass -fmessage-length=. 2424 CmdArgs.push_back("-fmessage-length"); 2425 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 2426 CmdArgs.push_back(A->getValue()); 2427 } else { 2428 // If -fmessage-length=N was not specified, determine whether this is a 2429 // terminal and, if so, implicitly define -fmessage-length appropriately. 2430 unsigned N = llvm::sys::Process::StandardErrColumns(); 2431 CmdArgs.push_back(Args.MakeArgString(Twine(N))); 2432 } 2433 2434 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) { 2435 CmdArgs.push_back("-fvisibility"); 2436 CmdArgs.push_back(A->getValue()); 2437 } 2438 2439 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden); 2440 2441 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); 2442 2443 // -fhosted is default. 2444 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) || 2445 KernelOrKext) 2446 CmdArgs.push_back("-ffreestanding"); 2447 2448 // Forward -f (flag) options which we can pass directly. 2449 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 2450 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions); 2451 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 2452 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info); 2453 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info); 2454 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names); 2455 Args.AddLastArg(CmdArgs, options::OPT_faltivec); 2456 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree); 2457 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type); 2458 2459 SanitizerArgs Sanitize(D, Args); 2460 Sanitize.addArgs(Args, CmdArgs); 2461 2462 // Report and error for -faltivec on anything other then PowerPC. 2463 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) 2464 if (!(getToolChain().getTriple().getArch() == llvm::Triple::ppc || 2465 getToolChain().getTriple().getArch() == llvm::Triple::ppc64)) 2466 D.Diag(diag::err_drv_argument_only_allowed_with) 2467 << A->getAsString(Args) << "ppc/ppc64"; 2468 2469 if (getToolChain().SupportsProfiling()) 2470 Args.AddLastArg(CmdArgs, options::OPT_pg); 2471 2472 // -flax-vector-conversions is default. 2473 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 2474 options::OPT_fno_lax_vector_conversions)) 2475 CmdArgs.push_back("-fno-lax-vector-conversions"); 2476 2477 if (Args.getLastArg(options::OPT_fapple_kext)) 2478 CmdArgs.push_back("-fapple-kext"); 2479 2480 if (Args.hasFlag(options::OPT_frewrite_includes, 2481 options::OPT_fno_rewrite_includes, false)) 2482 CmdArgs.push_back("-frewrite-includes"); 2483 2484 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 2485 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 2486 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 2487 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 2488 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 2489 2490 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 2491 CmdArgs.push_back("-ftrapv-handler"); 2492 CmdArgs.push_back(A->getValue()); 2493 } 2494 2495 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ); 2496 2497 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but 2498 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. 2499 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, 2500 options::OPT_fno_wrapv)) { 2501 if (A->getOption().matches(options::OPT_fwrapv)) 2502 CmdArgs.push_back("-fwrapv"); 2503 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, 2504 options::OPT_fno_strict_overflow)) { 2505 if (A->getOption().matches(options::OPT_fno_strict_overflow)) 2506 CmdArgs.push_back("-fwrapv"); 2507 } 2508 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 2509 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops); 2510 2511 Args.AddLastArg(CmdArgs, options::OPT_pthread); 2512 2513 2514 // -stack-protector=0 is default. 2515 unsigned StackProtectorLevel = 0; 2516 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 2517 options::OPT_fstack_protector_all, 2518 options::OPT_fstack_protector)) { 2519 if (A->getOption().matches(options::OPT_fstack_protector)) 2520 StackProtectorLevel = 1; 2521 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 2522 StackProtectorLevel = 2; 2523 } else { 2524 StackProtectorLevel = 2525 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext); 2526 } 2527 if (StackProtectorLevel) { 2528 CmdArgs.push_back("-stack-protector"); 2529 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); 2530 } 2531 2532 // --param ssp-buffer-size= 2533 for (arg_iterator it = Args.filtered_begin(options::OPT__param), 2534 ie = Args.filtered_end(); it != ie; ++it) { 2535 StringRef Str((*it)->getValue()); 2536 if (Str.startswith("ssp-buffer-size=")) { 2537 if (StackProtectorLevel) { 2538 CmdArgs.push_back("-stack-protector-buffer-size"); 2539 // FIXME: Verify the argument is a valid integer. 2540 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16))); 2541 } 2542 (*it)->claim(); 2543 } 2544 } 2545 2546 // Translate -mstackrealign 2547 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign, 2548 false)) { 2549 CmdArgs.push_back("-backend-option"); 2550 CmdArgs.push_back("-force-align-stack"); 2551 } 2552 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign, 2553 false)) { 2554 CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); 2555 } 2556 2557 if (Args.hasArg(options::OPT_mstack_alignment)) { 2558 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment); 2559 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment)); 2560 } 2561 if (Args.hasArg(options::OPT_mstrict_align)) { 2562 CmdArgs.push_back("-backend-option"); 2563 CmdArgs.push_back("-arm-strict-align"); 2564 } 2565 2566 // Forward -f options with positive and negative forms; we translate 2567 // these by hand. 2568 2569 if (Args.hasArg(options::OPT_mkernel)) { 2570 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType)) 2571 CmdArgs.push_back("-fapple-kext"); 2572 if (!Args.hasArg(options::OPT_fbuiltin)) 2573 CmdArgs.push_back("-fno-builtin"); 2574 Args.ClaimAllArgs(options::OPT_fno_builtin); 2575 } 2576 // -fbuiltin is default. 2577 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 2578 CmdArgs.push_back("-fno-builtin"); 2579 2580 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 2581 options::OPT_fno_assume_sane_operator_new)) 2582 CmdArgs.push_back("-fno-assume-sane-operator-new"); 2583 2584 // -fblocks=0 is default. 2585 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 2586 getToolChain().IsBlocksDefault()) || 2587 (Args.hasArg(options::OPT_fgnu_runtime) && 2588 Args.hasArg(options::OPT_fobjc_nonfragile_abi) && 2589 !Args.hasArg(options::OPT_fno_blocks))) { 2590 CmdArgs.push_back("-fblocks"); 2591 2592 if (!Args.hasArg(options::OPT_fgnu_runtime) && 2593 !getToolChain().hasBlocksRuntime()) 2594 CmdArgs.push_back("-fblocks-runtime-optional"); 2595 } 2596 2597 // -fmodules enables modules (off by default). However, for C++/Objective-C++, 2598 // users must also pass -fcxx-modules. The latter flag will disappear once the 2599 // modules implementation is solid for C++/Objective-C++ programs as well. 2600 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { 2601 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, 2602 options::OPT_fno_cxx_modules, 2603 false); 2604 if (AllowedInCXX || !types::isCXX(InputType)) 2605 CmdArgs.push_back("-fmodules"); 2606 } 2607 2608 // -faccess-control is default. 2609 if (Args.hasFlag(options::OPT_fno_access_control, 2610 options::OPT_faccess_control, 2611 false)) 2612 CmdArgs.push_back("-fno-access-control"); 2613 2614 // -felide-constructors is the default. 2615 if (Args.hasFlag(options::OPT_fno_elide_constructors, 2616 options::OPT_felide_constructors, 2617 false)) 2618 CmdArgs.push_back("-fno-elide-constructors"); 2619 2620 // -frtti is default. 2621 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) || 2622 KernelOrKext) { 2623 CmdArgs.push_back("-fno-rtti"); 2624 2625 // -fno-rtti cannot usefully be combined with -fsanitize=vptr. 2626 if (Sanitize.sanitizesVptr()) { 2627 std::string NoRttiArg = 2628 Args.getLastArg(options::OPT_mkernel, 2629 options::OPT_fapple_kext, 2630 options::OPT_fno_rtti)->getAsString(Args); 2631 D.Diag(diag::err_drv_argument_not_allowed_with) 2632 << "-fsanitize=vptr" << NoRttiArg; 2633 } 2634 } 2635 2636 // -fshort-enums=0 is default for all architectures except Hexagon. 2637 if (Args.hasFlag(options::OPT_fshort_enums, 2638 options::OPT_fno_short_enums, 2639 getToolChain().getTriple().getArch() == 2640 llvm::Triple::hexagon)) 2641 CmdArgs.push_back("-fshort-enums"); 2642 2643 // -fsigned-char is default. 2644 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 2645 isSignedCharDefault(getToolChain().getTriple()))) 2646 CmdArgs.push_back("-fno-signed-char"); 2647 2648 // -fthreadsafe-static is default. 2649 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 2650 options::OPT_fno_threadsafe_statics)) 2651 CmdArgs.push_back("-fno-threadsafe-statics"); 2652 2653 // -fuse-cxa-atexit is default. 2654 if (!Args.hasFlag(options::OPT_fuse_cxa_atexit, 2655 options::OPT_fno_use_cxa_atexit, 2656 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin && 2657 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 && 2658 getToolChain().getTriple().getArch() != llvm::Triple::hexagon) || 2659 KernelOrKext) 2660 CmdArgs.push_back("-fno-use-cxa-atexit"); 2661 2662 // -fms-extensions=0 is default. 2663 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 2664 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 2665 CmdArgs.push_back("-fms-extensions"); 2666 2667 // -fms-inline-asm. 2668 if (Args.hasArg(options::OPT_fenable_experimental_ms_inline_asm)) 2669 CmdArgs.push_back("-fenable-experimental-ms-inline-asm"); 2670 2671 // -fms-compatibility=0 is default. 2672 if (Args.hasFlag(options::OPT_fms_compatibility, 2673 options::OPT_fno_ms_compatibility, 2674 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 && 2675 Args.hasFlag(options::OPT_fms_extensions, 2676 options::OPT_fno_ms_extensions, 2677 true)))) 2678 CmdArgs.push_back("-fms-compatibility"); 2679 2680 // -fmsc-version=1300 is default. 2681 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 2682 getToolChain().getTriple().getOS() == llvm::Triple::Win32) || 2683 Args.hasArg(options::OPT_fmsc_version)) { 2684 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version); 2685 if (msc_ver.empty()) 2686 CmdArgs.push_back("-fmsc-version=1300"); 2687 else 2688 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver)); 2689 } 2690 2691 2692 // -fborland-extensions=0 is default. 2693 if (Args.hasFlag(options::OPT_fborland_extensions, 2694 options::OPT_fno_borland_extensions, false)) 2695 CmdArgs.push_back("-fborland-extensions"); 2696 2697 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL 2698 // needs it. 2699 if (Args.hasFlag(options::OPT_fdelayed_template_parsing, 2700 options::OPT_fno_delayed_template_parsing, 2701 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 2702 CmdArgs.push_back("-fdelayed-template-parsing"); 2703 2704 // -fgnu-keywords default varies depending on language; only pass if 2705 // specified. 2706 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 2707 options::OPT_fno_gnu_keywords)) 2708 A->render(Args, CmdArgs); 2709 2710 if (Args.hasFlag(options::OPT_fgnu89_inline, 2711 options::OPT_fno_gnu89_inline, 2712 false)) 2713 CmdArgs.push_back("-fgnu89-inline"); 2714 2715 if (Args.hasArg(options::OPT_fno_inline)) 2716 CmdArgs.push_back("-fno-inline"); 2717 2718 if (Args.hasArg(options::OPT_fno_inline_functions)) 2719 CmdArgs.push_back("-fno-inline-functions"); 2720 2721 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind); 2722 2723 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and 2724 // legacy is the default. 2725 if (objcRuntime.isNonFragile()) { 2726 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 2727 options::OPT_fno_objc_legacy_dispatch, 2728 objcRuntime.isLegacyDispatchDefaultForArch( 2729 getToolChain().getTriple().getArch()))) { 2730 if (getToolChain().UseObjCMixedDispatch()) 2731 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 2732 else 2733 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 2734 } 2735 } 2736 2737 // -fobjc-default-synthesize-properties=1 is default. This only has an effect 2738 // if the nonfragile objc abi is used. 2739 if (getToolChain().IsObjCDefaultSynthPropertiesDefault()) { 2740 CmdArgs.push_back("-fobjc-default-synthesize-properties"); 2741 } 2742 2743 // -fencode-extended-block-signature=1 is default. 2744 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) { 2745 CmdArgs.push_back("-fencode-extended-block-signature"); 2746 } 2747 2748 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. 2749 // NOTE: This logic is duplicated in ToolChains.cpp. 2750 bool ARC = isObjCAutoRefCount(Args); 2751 if (ARC) { 2752 getToolChain().CheckObjCARC(); 2753 2754 CmdArgs.push_back("-fobjc-arc"); 2755 2756 // FIXME: It seems like this entire block, and several around it should be 2757 // wrapped in isObjC, but for now we just use it here as this is where it 2758 // was being used previously. 2759 if (types::isCXX(InputType) && types::isObjC(InputType)) { 2760 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) 2761 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++"); 2762 else 2763 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++"); 2764 } 2765 2766 // Allow the user to enable full exceptions code emission. 2767 // We define off for Objective-CC, on for Objective-C++. 2768 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions, 2769 options::OPT_fno_objc_arc_exceptions, 2770 /*default*/ types::isCXX(InputType))) 2771 CmdArgs.push_back("-fobjc-arc-exceptions"); 2772 } 2773 2774 // -fobjc-infer-related-result-type is the default, except in the Objective-C 2775 // rewriter. 2776 if (rewriteKind != RK_None) 2777 CmdArgs.push_back("-fno-objc-infer-related-result-type"); 2778 2779 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only 2780 // takes precedence. 2781 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only); 2782 if (!GCArg) 2783 GCArg = Args.getLastArg(options::OPT_fobjc_gc); 2784 if (GCArg) { 2785 if (ARC) { 2786 D.Diag(diag::err_drv_objc_gc_arr) 2787 << GCArg->getAsString(Args); 2788 } else if (getToolChain().SupportsObjCGC()) { 2789 GCArg->render(Args, CmdArgs); 2790 } else { 2791 // FIXME: We should move this to a hard error. 2792 D.Diag(diag::warn_drv_objc_gc_unsupported) 2793 << GCArg->getAsString(Args); 2794 } 2795 } 2796 2797 // Add exception args. 2798 addExceptionArgs(Args, InputType, getToolChain().getTriple(), 2799 KernelOrKext, objcRuntime, CmdArgs); 2800 2801 if (getToolChain().UseSjLjExceptions()) 2802 CmdArgs.push_back("-fsjlj-exceptions"); 2803 2804 // C++ "sane" operator new. 2805 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 2806 options::OPT_fno_assume_sane_operator_new)) 2807 CmdArgs.push_back("-fno-assume-sane-operator-new"); 2808 2809 // -fconstant-cfstrings is default, and may be subject to argument translation 2810 // on Darwin. 2811 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 2812 options::OPT_fno_constant_cfstrings) || 2813 !Args.hasFlag(options::OPT_mconstant_cfstrings, 2814 options::OPT_mno_constant_cfstrings)) 2815 CmdArgs.push_back("-fno-constant-cfstrings"); 2816 2817 // -fshort-wchar default varies depending on platform; only 2818 // pass if specified. 2819 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) 2820 A->render(Args, CmdArgs); 2821 2822 // -fno-pascal-strings is default, only pass non-default. If the tool chain 2823 // happened to translate to -mpascal-strings, we want to back translate here. 2824 // 2825 // FIXME: This is gross; that translation should be pulled from the 2826 // tool chain. 2827 if (Args.hasFlag(options::OPT_fpascal_strings, 2828 options::OPT_fno_pascal_strings, 2829 false) || 2830 Args.hasFlag(options::OPT_mpascal_strings, 2831 options::OPT_mno_pascal_strings, 2832 false)) 2833 CmdArgs.push_back("-fpascal-strings"); 2834 2835 // Honor -fpack-struct= and -fpack-struct, if given. Note that 2836 // -fno-pack-struct doesn't apply to -fpack-struct=. 2837 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) { 2838 std::string PackStructStr = "-fpack-struct="; 2839 PackStructStr += A->getValue(); 2840 CmdArgs.push_back(Args.MakeArgString(PackStructStr)); 2841 } else if (Args.hasFlag(options::OPT_fpack_struct, 2842 options::OPT_fno_pack_struct, false)) { 2843 CmdArgs.push_back("-fpack-struct=1"); 2844 } 2845 2846 if (Args.hasArg(options::OPT_mkernel) || 2847 Args.hasArg(options::OPT_fapple_kext)) { 2848 if (!Args.hasArg(options::OPT_fcommon)) 2849 CmdArgs.push_back("-fno-common"); 2850 Args.ClaimAllArgs(options::OPT_fno_common); 2851 } 2852 2853 // -fcommon is default, only pass non-default. 2854 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 2855 CmdArgs.push_back("-fno-common"); 2856 2857 // -fsigned-bitfields is default, and clang doesn't yet support 2858 // -funsigned-bitfields. 2859 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 2860 options::OPT_funsigned_bitfields)) 2861 D.Diag(diag::warn_drv_clang_unsupported) 2862 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 2863 2864 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 2865 if (!Args.hasFlag(options::OPT_ffor_scope, 2866 options::OPT_fno_for_scope)) 2867 D.Diag(diag::err_drv_clang_unsupported) 2868 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 2869 2870 // -fcaret-diagnostics is default. 2871 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 2872 options::OPT_fno_caret_diagnostics, true)) 2873 CmdArgs.push_back("-fno-caret-diagnostics"); 2874 2875 // -fdiagnostics-fixit-info is default, only pass non-default. 2876 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 2877 options::OPT_fno_diagnostics_fixit_info)) 2878 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 2879 2880 // Enable -fdiagnostics-show-option by default. 2881 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 2882 options::OPT_fno_diagnostics_show_option)) 2883 CmdArgs.push_back("-fdiagnostics-show-option"); 2884 2885 if (const Arg *A = 2886 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 2887 CmdArgs.push_back("-fdiagnostics-show-category"); 2888 CmdArgs.push_back(A->getValue()); 2889 } 2890 2891 if (const Arg *A = 2892 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { 2893 CmdArgs.push_back("-fdiagnostics-format"); 2894 CmdArgs.push_back(A->getValue()); 2895 } 2896 2897 if (Arg *A = Args.getLastArg( 2898 options::OPT_fdiagnostics_show_note_include_stack, 2899 options::OPT_fno_diagnostics_show_note_include_stack)) { 2900 if (A->getOption().matches( 2901 options::OPT_fdiagnostics_show_note_include_stack)) 2902 CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); 2903 else 2904 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); 2905 } 2906 2907 // Color diagnostics are the default, unless the terminal doesn't support 2908 // them. 2909 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 2910 options::OPT_fno_color_diagnostics, 2911 llvm::sys::Process::StandardErrHasColors())) 2912 CmdArgs.push_back("-fcolor-diagnostics"); 2913 2914 if (!Args.hasFlag(options::OPT_fshow_source_location, 2915 options::OPT_fno_show_source_location)) 2916 CmdArgs.push_back("-fno-show-source-location"); 2917 2918 if (!Args.hasFlag(options::OPT_fshow_column, 2919 options::OPT_fno_show_column, 2920 true)) 2921 CmdArgs.push_back("-fno-show-column"); 2922 2923 if (!Args.hasFlag(options::OPT_fspell_checking, 2924 options::OPT_fno_spell_checking)) 2925 CmdArgs.push_back("-fno-spell-checking"); 2926 2927 2928 // Silently ignore -fasm-blocks for now. 2929 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, 2930 false); 2931 2932 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ)) 2933 A->render(Args, CmdArgs); 2934 2935 // -fdollars-in-identifiers default varies depending on platform and 2936 // language; only pass if specified. 2937 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 2938 options::OPT_fno_dollars_in_identifiers)) { 2939 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 2940 CmdArgs.push_back("-fdollars-in-identifiers"); 2941 else 2942 CmdArgs.push_back("-fno-dollars-in-identifiers"); 2943 } 2944 2945 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 2946 // practical purposes. 2947 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 2948 options::OPT_fno_unit_at_a_time)) { 2949 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 2950 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); 2951 } 2952 2953 if (Args.hasFlag(options::OPT_fapple_pragma_pack, 2954 options::OPT_fno_apple_pragma_pack, false)) 2955 CmdArgs.push_back("-fapple-pragma-pack"); 2956 2957 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 2958 // 2959 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 2960#if 0 2961 if (getToolChain().getTriple().isOSDarwin() && 2962 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2963 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 2964 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 2965 CmdArgs.push_back("-fno-builtin-strcat"); 2966 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 2967 CmdArgs.push_back("-fno-builtin-strcpy"); 2968 } 2969#endif 2970 2971 // Only allow -traditional or -traditional-cpp outside in preprocessing modes. 2972 if (Arg *A = Args.getLastArg(options::OPT_traditional, 2973 options::OPT_traditional_cpp)) { 2974 if (isa<PreprocessJobAction>(JA)) 2975 CmdArgs.push_back("-traditional-cpp"); 2976 else 2977 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 2978 } 2979 2980 Args.AddLastArg(CmdArgs, options::OPT_dM); 2981 Args.AddLastArg(CmdArgs, options::OPT_dD); 2982 2983 // Handle serialized diagnostics. 2984 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) { 2985 CmdArgs.push_back("-serialize-diagnostic-file"); 2986 CmdArgs.push_back(Args.MakeArgString(A->getValue())); 2987 } 2988 2989 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers)) 2990 CmdArgs.push_back("-fretain-comments-from-system-headers"); 2991 2992 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 2993 // parser. 2994 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 2995 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm), 2996 ie = Args.filtered_end(); it != ie; ++it) { 2997 (*it)->claim(); 2998 2999 // We translate this by hand to the -cc1 argument, since nightly test uses 3000 // it and developers have been trained to spell it with -mllvm. 3001 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") 3002 CmdArgs.push_back("-disable-llvm-optzns"); 3003 else 3004 (*it)->render(Args, CmdArgs); 3005 } 3006 3007 if (Output.getType() == types::TY_Dependencies) { 3008 // Handled with other dependency code. 3009 } else if (Output.isFilename()) { 3010 CmdArgs.push_back("-o"); 3011 CmdArgs.push_back(Output.getFilename()); 3012 } else { 3013 assert(Output.isNothing() && "Invalid output."); 3014 } 3015 3016 for (InputInfoList::const_iterator 3017 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3018 const InputInfo &II = *it; 3019 CmdArgs.push_back("-x"); 3020 if (Args.hasArg(options::OPT_rewrite_objc)) 3021 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX)); 3022 else 3023 CmdArgs.push_back(types::getTypeName(II.getType())); 3024 if (II.isFilename()) 3025 CmdArgs.push_back(II.getFilename()); 3026 else 3027 II.getInputArg().renderAsInput(Args, CmdArgs); 3028 } 3029 3030 Args.AddAllArgs(CmdArgs, options::OPT_undef); 3031 3032 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 3033 3034 // Optionally embed the -cc1 level arguments into the debug info, for build 3035 // analysis. 3036 if (getToolChain().UseDwarfDebugFlags()) { 3037 ArgStringList OriginalArgs; 3038 for (ArgList::const_iterator it = Args.begin(), 3039 ie = Args.end(); it != ie; ++it) 3040 (*it)->render(Args, OriginalArgs); 3041 3042 SmallString<256> Flags; 3043 Flags += Exec; 3044 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 3045 Flags += " "; 3046 Flags += OriginalArgs[i]; 3047 } 3048 CmdArgs.push_back("-dwarf-debug-flags"); 3049 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 3050 } 3051 3052 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3053 3054 if (Arg *A = Args.getLastArg(options::OPT_pg)) 3055 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 3056 D.Diag(diag::err_drv_argument_not_allowed_with) 3057 << "-fomit-frame-pointer" << A->getAsString(Args); 3058 3059 // Claim some arguments which clang supports automatically. 3060 3061 // -fpch-preprocess is used with gcc to add a special marker in the output to 3062 // include the PCH file. Clang's PTH solution is completely transparent, so we 3063 // do not need to deal with it at all. 3064 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 3065 3066 // Claim some arguments which clang doesn't support, but we don't 3067 // care to warn the user about. 3068 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 3069 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 3070 3071 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c 3072 Args.ClaimAllArgs(options::OPT_use_gold_plugin); 3073 Args.ClaimAllArgs(options::OPT_emit_llvm); 3074} 3075 3076void ClangAs::AddARMTargetArgs(const ArgList &Args, 3077 ArgStringList &CmdArgs) const { 3078 const Driver &D = getToolChain().getDriver(); 3079 llvm::Triple Triple = getToolChain().getTriple(); 3080 3081 // Set the CPU based on -march= and -mcpu=. 3082 CmdArgs.push_back("-target-cpu"); 3083 CmdArgs.push_back(Args.MakeArgString(getARMTargetCPU(Args, Triple))); 3084 3085 // Honor -mfpu=. 3086 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) 3087 addFPUArgs(D, A, Args, CmdArgs); 3088 3089 // Honor -mfpmath=. 3090 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) 3091 addFPMathArgs(D, A, Args, CmdArgs, getARMTargetCPU(Args, Triple)); 3092} 3093 3094/// Add options related to the Objective-C runtime/ABI. 3095/// 3096/// Returns true if the runtime is non-fragile. 3097ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, 3098 ArgStringList &cmdArgs, 3099 RewriteKind rewriteKind) const { 3100 // Look for the controlling runtime option. 3101 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime, 3102 options::OPT_fgnu_runtime, 3103 options::OPT_fobjc_runtime_EQ); 3104 3105 // Just forward -fobjc-runtime= to the frontend. This supercedes 3106 // options about fragility. 3107 if (runtimeArg && 3108 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) { 3109 ObjCRuntime runtime; 3110 StringRef value = runtimeArg->getValue(); 3111 if (runtime.tryParse(value)) { 3112 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime) 3113 << value; 3114 } 3115 3116 runtimeArg->render(args, cmdArgs); 3117 return runtime; 3118 } 3119 3120 // Otherwise, we'll need the ABI "version". Version numbers are 3121 // slightly confusing for historical reasons: 3122 // 1 - Traditional "fragile" ABI 3123 // 2 - Non-fragile ABI, version 1 3124 // 3 - Non-fragile ABI, version 2 3125 unsigned objcABIVersion = 1; 3126 // If -fobjc-abi-version= is present, use that to set the version. 3127 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 3128 StringRef value = abiArg->getValue(); 3129 if (value == "1") 3130 objcABIVersion = 1; 3131 else if (value == "2") 3132 objcABIVersion = 2; 3133 else if (value == "3") 3134 objcABIVersion = 3; 3135 else 3136 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 3137 << value; 3138 } else { 3139 // Otherwise, determine if we are using the non-fragile ABI. 3140 bool nonFragileABIIsDefault = 3141 (rewriteKind == RK_NonFragile || 3142 (rewriteKind == RK_None && 3143 getToolChain().IsObjCNonFragileABIDefault())); 3144 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi, 3145 options::OPT_fno_objc_nonfragile_abi, 3146 nonFragileABIIsDefault)) { 3147 // Determine the non-fragile ABI version to use. 3148#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 3149 unsigned nonFragileABIVersion = 1; 3150#else 3151 unsigned nonFragileABIVersion = 2; 3152#endif 3153 3154 if (Arg *abiArg = args.getLastArg( 3155 options::OPT_fobjc_nonfragile_abi_version_EQ)) { 3156 StringRef value = abiArg->getValue(); 3157 if (value == "1") 3158 nonFragileABIVersion = 1; 3159 else if (value == "2") 3160 nonFragileABIVersion = 2; 3161 else 3162 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 3163 << value; 3164 } 3165 3166 objcABIVersion = 1 + nonFragileABIVersion; 3167 } else { 3168 objcABIVersion = 1; 3169 } 3170 } 3171 3172 // We don't actually care about the ABI version other than whether 3173 // it's non-fragile. 3174 bool isNonFragile = objcABIVersion != 1; 3175 3176 // If we have no runtime argument, ask the toolchain for its default runtime. 3177 // However, the rewriter only really supports the Mac runtime, so assume that. 3178 ObjCRuntime runtime; 3179 if (!runtimeArg) { 3180 switch (rewriteKind) { 3181 case RK_None: 3182 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 3183 break; 3184 case RK_Fragile: 3185 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple()); 3186 break; 3187 case RK_NonFragile: 3188 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 3189 break; 3190 } 3191 3192 // -fnext-runtime 3193 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) { 3194 // On Darwin, make this use the default behavior for the toolchain. 3195 if (getToolChain().getTriple().isOSDarwin()) { 3196 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 3197 3198 // Otherwise, build for a generic macosx port. 3199 } else { 3200 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 3201 } 3202 3203 // -fgnu-runtime 3204 } else { 3205 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime)); 3206 // Legacy behaviour is to target the gnustep runtime if we are i 3207 // non-fragile mode or the GCC runtime in fragile mode. 3208 if (isNonFragile) 3209 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6)); 3210 else 3211 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple()); 3212 } 3213 3214 cmdArgs.push_back(args.MakeArgString( 3215 "-fobjc-runtime=" + runtime.getAsString())); 3216 return runtime; 3217} 3218 3219void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 3220 const InputInfo &Output, 3221 const InputInfoList &Inputs, 3222 const ArgList &Args, 3223 const char *LinkingOutput) const { 3224 ArgStringList CmdArgs; 3225 3226 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 3227 const InputInfo &Input = Inputs[0]; 3228 3229 // Don't warn about "clang -w -c foo.s" 3230 Args.ClaimAllArgs(options::OPT_w); 3231 // and "clang -emit-llvm -c foo.s" 3232 Args.ClaimAllArgs(options::OPT_emit_llvm); 3233 // and "clang -use-gold-plugin -c foo.s" 3234 Args.ClaimAllArgs(options::OPT_use_gold_plugin); 3235 3236 // Invoke ourselves in -cc1as mode. 3237 // 3238 // FIXME: Implement custom jobs for internal actions. 3239 CmdArgs.push_back("-cc1as"); 3240 3241 // Add the "effective" target triple. 3242 CmdArgs.push_back("-triple"); 3243 std::string TripleStr = 3244 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType()); 3245 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 3246 3247 // Set the output mode, we currently only expect to be used as a real 3248 // assembler. 3249 CmdArgs.push_back("-filetype"); 3250 CmdArgs.push_back("obj"); 3251 3252 if (UseRelaxAll(C, Args)) 3253 CmdArgs.push_back("-relax-all"); 3254 3255 // Add target specific cpu and features flags. 3256 switch(getToolChain().getTriple().getArch()) { 3257 default: 3258 break; 3259 3260 case llvm::Triple::arm: 3261 case llvm::Triple::thumb: 3262 AddARMTargetArgs(Args, CmdArgs); 3263 break; 3264 } 3265 3266 // Ignore explicit -force_cpusubtype_ALL option. 3267 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 3268 3269 // Determine the original source input. 3270 const Action *SourceAction = &JA; 3271 while (SourceAction->getKind() != Action::InputClass) { 3272 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 3273 SourceAction = SourceAction->getInputs()[0]; 3274 } 3275 3276 // Forward -g, assuming we are dealing with an actual assembly file. 3277 if (SourceAction->getType() == types::TY_Asm || 3278 SourceAction->getType() == types::TY_PP_Asm) { 3279 Args.ClaimAllArgs(options::OPT_g_Group); 3280 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 3281 if (!A->getOption().matches(options::OPT_g0)) 3282 CmdArgs.push_back("-g"); 3283 } 3284 3285 // Optionally embed the -cc1as level arguments into the debug info, for build 3286 // analysis. 3287 if (getToolChain().UseDwarfDebugFlags()) { 3288 ArgStringList OriginalArgs; 3289 for (ArgList::const_iterator it = Args.begin(), 3290 ie = Args.end(); it != ie; ++it) 3291 (*it)->render(Args, OriginalArgs); 3292 3293 SmallString<256> Flags; 3294 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 3295 Flags += Exec; 3296 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 3297 Flags += " "; 3298 Flags += OriginalArgs[i]; 3299 } 3300 CmdArgs.push_back("-dwarf-debug-flags"); 3301 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 3302 } 3303 3304 // FIXME: Add -static support, once we have it. 3305 3306 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3307 options::OPT_Xassembler); 3308 Args.AddAllArgs(CmdArgs, options::OPT_mllvm); 3309 3310 assert(Output.isFilename() && "Unexpected lipo output."); 3311 CmdArgs.push_back("-o"); 3312 CmdArgs.push_back(Output.getFilename()); 3313 3314 assert(Input.isFilename() && "Invalid input."); 3315 CmdArgs.push_back(Input.getFilename()); 3316 3317 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 3318 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3319} 3320 3321void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 3322 const InputInfo &Output, 3323 const InputInfoList &Inputs, 3324 const ArgList &Args, 3325 const char *LinkingOutput) const { 3326 const Driver &D = getToolChain().getDriver(); 3327 ArgStringList CmdArgs; 3328 3329 for (ArgList::const_iterator 3330 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 3331 Arg *A = *it; 3332 if (forwardToGCC(A->getOption())) { 3333 // Don't forward any -g arguments to assembly steps. 3334 if (isa<AssembleJobAction>(JA) && 3335 A->getOption().matches(options::OPT_g_Group)) 3336 continue; 3337 3338 // It is unfortunate that we have to claim here, as this means 3339 // we will basically never report anything interesting for 3340 // platforms using a generic gcc, even if we are just using gcc 3341 // to get to the assembler. 3342 A->claim(); 3343 A->render(Args, CmdArgs); 3344 } 3345 } 3346 3347 RenderExtraToolArgs(JA, CmdArgs); 3348 3349 // If using a driver driver, force the arch. 3350 llvm::Triple::ArchType Arch = getToolChain().getArch(); 3351 if (getToolChain().getTriple().isOSDarwin()) { 3352 CmdArgs.push_back("-arch"); 3353 3354 // FIXME: Remove these special cases. 3355 if (Arch == llvm::Triple::ppc) 3356 CmdArgs.push_back("ppc"); 3357 else if (Arch == llvm::Triple::ppc64) 3358 CmdArgs.push_back("ppc64"); 3359 else 3360 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName())); 3361 } 3362 3363 // Try to force gcc to match the tool chain we want, if we recognize 3364 // the arch. 3365 // 3366 // FIXME: The triple class should directly provide the information we want 3367 // here. 3368 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc) 3369 CmdArgs.push_back("-m32"); 3370 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86_64) 3371 CmdArgs.push_back("-m64"); 3372 3373 if (Output.isFilename()) { 3374 CmdArgs.push_back("-o"); 3375 CmdArgs.push_back(Output.getFilename()); 3376 } else { 3377 assert(Output.isNothing() && "Unexpected output"); 3378 CmdArgs.push_back("-fsyntax-only"); 3379 } 3380 3381 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3382 options::OPT_Xassembler); 3383 3384 // Only pass -x if gcc will understand it; otherwise hope gcc 3385 // understands the suffix correctly. The main use case this would go 3386 // wrong in is for linker inputs if they happened to have an odd 3387 // suffix; really the only way to get this to happen is a command 3388 // like '-x foobar a.c' which will treat a.c like a linker input. 3389 // 3390 // FIXME: For the linker case specifically, can we safely convert 3391 // inputs into '-Wl,' options? 3392 for (InputInfoList::const_iterator 3393 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3394 const InputInfo &II = *it; 3395 3396 // Don't try to pass LLVM or AST inputs to a generic gcc. 3397 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 3398 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 3399 D.Diag(diag::err_drv_no_linker_llvm_support) 3400 << getToolChain().getTripleString(); 3401 else if (II.getType() == types::TY_AST) 3402 D.Diag(diag::err_drv_no_ast_support) 3403 << getToolChain().getTripleString(); 3404 3405 if (types::canTypeBeUserSpecified(II.getType())) { 3406 CmdArgs.push_back("-x"); 3407 CmdArgs.push_back(types::getTypeName(II.getType())); 3408 } 3409 3410 if (II.isFilename()) 3411 CmdArgs.push_back(II.getFilename()); 3412 else { 3413 const Arg &A = II.getInputArg(); 3414 3415 // Reverse translate some rewritten options. 3416 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 3417 CmdArgs.push_back("-lstdc++"); 3418 continue; 3419 } 3420 3421 // Don't render as input, we need gcc to do the translations. 3422 A.render(Args, CmdArgs); 3423 } 3424 } 3425 3426 const std::string customGCCName = D.getCCCGenericGCCName(); 3427 const char *GCCName; 3428 if (!customGCCName.empty()) 3429 GCCName = customGCCName.c_str(); 3430 else if (D.CCCIsCXX) { 3431 GCCName = "g++"; 3432 } else 3433 GCCName = "gcc"; 3434 3435 const char *Exec = 3436 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 3437 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3438} 3439 3440void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 3441 ArgStringList &CmdArgs) const { 3442 CmdArgs.push_back("-E"); 3443} 3444 3445void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 3446 ArgStringList &CmdArgs) const { 3447 // The type is good enough. 3448} 3449 3450void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 3451 ArgStringList &CmdArgs) const { 3452 const Driver &D = getToolChain().getDriver(); 3453 3454 // If -flto, etc. are present then make sure not to force assembly output. 3455 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR || 3456 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC) 3457 CmdArgs.push_back("-c"); 3458 else { 3459 if (JA.getType() != types::TY_PP_Asm) 3460 D.Diag(diag::err_drv_invalid_gcc_output_type) 3461 << getTypeName(JA.getType()); 3462 3463 CmdArgs.push_back("-S"); 3464 } 3465} 3466 3467void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 3468 ArgStringList &CmdArgs) const { 3469 CmdArgs.push_back("-c"); 3470} 3471 3472void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 3473 ArgStringList &CmdArgs) const { 3474 // The types are (hopefully) good enough. 3475} 3476 3477// Hexagon tools start. 3478void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA, 3479 ArgStringList &CmdArgs) const { 3480 3481} 3482void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3483 const InputInfo &Output, 3484 const InputInfoList &Inputs, 3485 const ArgList &Args, 3486 const char *LinkingOutput) const { 3487 3488 const Driver &D = getToolChain().getDriver(); 3489 ArgStringList CmdArgs; 3490 3491 std::string MarchString = "-march="; 3492 MarchString += getHexagonTargetCPU(Args); 3493 CmdArgs.push_back(Args.MakeArgString(MarchString)); 3494 3495 RenderExtraToolArgs(JA, CmdArgs); 3496 3497 if (Output.isFilename()) { 3498 CmdArgs.push_back("-o"); 3499 CmdArgs.push_back(Output.getFilename()); 3500 } else { 3501 assert(Output.isNothing() && "Unexpected output"); 3502 CmdArgs.push_back("-fsyntax-only"); 3503 } 3504 3505 3506 // Only pass -x if gcc will understand it; otherwise hope gcc 3507 // understands the suffix correctly. The main use case this would go 3508 // wrong in is for linker inputs if they happened to have an odd 3509 // suffix; really the only way to get this to happen is a command 3510 // like '-x foobar a.c' which will treat a.c like a linker input. 3511 // 3512 // FIXME: For the linker case specifically, can we safely convert 3513 // inputs into '-Wl,' options? 3514 for (InputInfoList::const_iterator 3515 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3516 const InputInfo &II = *it; 3517 3518 // Don't try to pass LLVM or AST inputs to a generic gcc. 3519 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 3520 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 3521 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 3522 << getToolChain().getTripleString(); 3523 else if (II.getType() == types::TY_AST) 3524 D.Diag(clang::diag::err_drv_no_ast_support) 3525 << getToolChain().getTripleString(); 3526 3527 if (II.isFilename()) 3528 CmdArgs.push_back(II.getFilename()); 3529 else 3530 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ? 3531 II.getInputArg().render(Args, CmdArgs); 3532 } 3533 3534 const char *GCCName = "hexagon-as"; 3535 const char *Exec = 3536 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 3537 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3538 3539} 3540void hexagon::Link::RenderExtraToolArgs(const JobAction &JA, 3541 ArgStringList &CmdArgs) const { 3542 // The types are (hopefully) good enough. 3543} 3544 3545void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA, 3546 const InputInfo &Output, 3547 const InputInfoList &Inputs, 3548 const ArgList &Args, 3549 const char *LinkingOutput) const { 3550 3551 const Driver &D = getToolChain().getDriver(); 3552 ArgStringList CmdArgs; 3553 3554 for (ArgList::const_iterator 3555 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 3556 Arg *A = *it; 3557 if (forwardToGCC(A->getOption())) { 3558 // Don't forward any -g arguments to assembly steps. 3559 if (isa<AssembleJobAction>(JA) && 3560 A->getOption().matches(options::OPT_g_Group)) 3561 continue; 3562 3563 // It is unfortunate that we have to claim here, as this means 3564 // we will basically never report anything interesting for 3565 // platforms using a generic gcc, even if we are just using gcc 3566 // to get to the assembler. 3567 A->claim(); 3568 A->render(Args, CmdArgs); 3569 } 3570 } 3571 3572 RenderExtraToolArgs(JA, CmdArgs); 3573 3574 // Add Arch Information 3575 Arg *A; 3576 if ((A = getLastHexagonArchArg(Args))) { 3577 if (A->getOption().matches(options::OPT_m_Joined)) 3578 A->render(Args, CmdArgs); 3579 else 3580 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args))); 3581 } 3582 else { 3583 CmdArgs.push_back (Args.MakeArgString("-m" + getHexagonTargetCPU(Args))); 3584 } 3585 3586 CmdArgs.push_back("-mqdsp6-compat"); 3587 3588 const char *GCCName; 3589 if (C.getDriver().CCCIsCXX) 3590 GCCName = "hexagon-g++"; 3591 else 3592 GCCName = "hexagon-gcc"; 3593 const char *Exec = 3594 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 3595 3596 if (Output.isFilename()) { 3597 CmdArgs.push_back("-o"); 3598 CmdArgs.push_back(Output.getFilename()); 3599 } 3600 3601 for (InputInfoList::const_iterator 3602 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3603 const InputInfo &II = *it; 3604 3605 // Don't try to pass LLVM or AST inputs to a generic gcc. 3606 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 3607 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 3608 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 3609 << getToolChain().getTripleString(); 3610 else if (II.getType() == types::TY_AST) 3611 D.Diag(clang::diag::err_drv_no_ast_support) 3612 << getToolChain().getTripleString(); 3613 3614 if (II.isFilename()) 3615 CmdArgs.push_back(II.getFilename()); 3616 else 3617 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ? 3618 II.getInputArg().render(Args, CmdArgs); 3619 } 3620 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3621 3622} 3623// Hexagon tools end. 3624 3625llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) { 3626 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for 3627 // archs which Darwin doesn't use. 3628 3629 // The matching this routine does is fairly pointless, since it is neither the 3630 // complete architecture list, nor a reasonable subset. The problem is that 3631 // historically the driver driver accepts this and also ties its -march= 3632 // handling to the architecture name, so we need to be careful before removing 3633 // support for it. 3634 3635 // This code must be kept in sync with Clang's Darwin specific argument 3636 // translation. 3637 3638 return llvm::StringSwitch<llvm::Triple::ArchType>(Str) 3639 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc) 3640 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc) 3641 .Case("ppc64", llvm::Triple::ppc64) 3642 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86) 3643 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4", 3644 llvm::Triple::x86) 3645 .Case("x86_64", llvm::Triple::x86_64) 3646 // This is derived from the driver driver. 3647 .Cases("arm", "armv4t", "armv5", "armv6", llvm::Triple::arm) 3648 .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", llvm::Triple::arm) 3649 .Case("r600", llvm::Triple::r600) 3650 .Case("nvptx", llvm::Triple::nvptx) 3651 .Case("nvptx64", llvm::Triple::nvptx64) 3652 .Case("amdil", llvm::Triple::amdil) 3653 .Case("spir", llvm::Triple::spir) 3654 .Default(llvm::Triple::UnknownArch); 3655} 3656 3657const char *darwin::CC1::getCC1Name(types::ID Type) const { 3658 switch (Type) { 3659 default: 3660 llvm_unreachable("Unexpected type for Darwin CC1 tool."); 3661 case types::TY_Asm: 3662 case types::TY_C: case types::TY_CHeader: 3663 case types::TY_PP_C: case types::TY_PP_CHeader: 3664 return "cc1"; 3665 case types::TY_ObjC: case types::TY_ObjCHeader: 3666 case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias: 3667 case types::TY_PP_ObjCHeader: 3668 return "cc1obj"; 3669 case types::TY_CXX: case types::TY_CXXHeader: 3670 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 3671 return "cc1plus"; 3672 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 3673 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias: 3674 case types::TY_PP_ObjCXXHeader: 3675 return "cc1objplus"; 3676 } 3677} 3678 3679void darwin::CC1::anchor() {} 3680 3681const char *darwin::CC1::getBaseInputName(const ArgList &Args, 3682 const InputInfoList &Inputs) { 3683 return Args.MakeArgString( 3684 llvm::sys::path::filename(Inputs[0].getBaseInput())); 3685} 3686 3687const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 3688 const InputInfoList &Inputs) { 3689 const char *Str = getBaseInputName(Args, Inputs); 3690 3691 if (const char *End = strrchr(Str, '.')) 3692 return Args.MakeArgString(std::string(Str, End)); 3693 3694 return Str; 3695} 3696 3697const char * 3698darwin::CC1::getDependencyFileName(const ArgList &Args, 3699 const InputInfoList &Inputs) { 3700 // FIXME: Think about this more. 3701 std::string Res; 3702 3703 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 3704 std::string Str(OutputOpt->getValue()); 3705 Res = Str.substr(0, Str.rfind('.')); 3706 } else { 3707 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 3708 } 3709 return Args.MakeArgString(Res + ".d"); 3710} 3711 3712void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const { 3713 for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end(); 3714 it != ie;) { 3715 3716 StringRef Option = *it; 3717 bool RemoveOption = false; 3718 3719 // Erase both -fmodule-cache-path and its argument. 3720 if (Option.equals("-fmodule-cache-path") && it+2 != ie) { 3721 it = CmdArgs.erase(it, it+2); 3722 ie = CmdArgs.end(); 3723 continue; 3724 } 3725 3726 // Remove unsupported -f options. 3727 if (Option.startswith("-f")) { 3728 // Remove -f/-fno- to reduce the number of cases. 3729 if (Option.startswith("-fno-")) 3730 Option = Option.substr(5); 3731 else 3732 Option = Option.substr(2); 3733 RemoveOption = llvm::StringSwitch<bool>(Option) 3734 .Case("altivec", true) 3735 .Case("modules", true) 3736 .Case("diagnostics-show-note-include-stack", true) 3737 .Default(false); 3738 } 3739 3740 // Handle machine specific options. 3741 if (Option.startswith("-m")) { 3742 RemoveOption = llvm::StringSwitch<bool>(Option) 3743 .Case("-mthumb", true) 3744 .Case("-mno-thumb", true) 3745 .Case("-mno-fused-madd", true) 3746 .Case("-mlong-branch", true) 3747 .Case("-mlongcall", true) 3748 .Case("-mcpu=G4", true) 3749 .Case("-mcpu=G5", true) 3750 .Default(false); 3751 } 3752 3753 // Handle warning options. 3754 if (Option.startswith("-W")) { 3755 // Remove -W/-Wno- to reduce the number of cases. 3756 if (Option.startswith("-Wno-")) 3757 Option = Option.substr(5); 3758 else 3759 Option = Option.substr(2); 3760 3761 RemoveOption = llvm::StringSwitch<bool>(Option) 3762 .Case("address-of-temporary", true) 3763 .Case("ambiguous-member-template", true) 3764 .Case("analyzer-incompatible-plugin", true) 3765 .Case("array-bounds", true) 3766 .Case("array-bounds-pointer-arithmetic", true) 3767 .Case("bind-to-temporary-copy", true) 3768 .Case("bitwise-op-parentheses", true) 3769 .Case("bool-conversions", true) 3770 .Case("builtin-macro-redefined", true) 3771 .Case("c++-hex-floats", true) 3772 .Case("c++0x-compat", true) 3773 .Case("c++0x-extensions", true) 3774 .Case("c++0x-narrowing", true) 3775 .Case("c++11-compat", true) 3776 .Case("c++11-extensions", true) 3777 .Case("c++11-narrowing", true) 3778 .Case("conditional-uninitialized", true) 3779 .Case("constant-conversion", true) 3780 .Case("conversion-null", true) 3781 .Case("CFString-literal", true) 3782 .Case("constant-logical-operand", true) 3783 .Case("custom-atomic-properties", true) 3784 .Case("default-arg-special-member", true) 3785 .Case("delegating-ctor-cycles", true) 3786 .Case("delete-non-virtual-dtor", true) 3787 .Case("deprecated-implementations", true) 3788 .Case("deprecated-writable-strings", true) 3789 .Case("distributed-object-modifiers", true) 3790 .Case("duplicate-method-arg", true) 3791 .Case("dynamic-class-memaccess", true) 3792 .Case("enum-compare", true) 3793 .Case("enum-conversion", true) 3794 .Case("exit-time-destructors", true) 3795 .Case("gnu", true) 3796 .Case("gnu-designator", true) 3797 .Case("header-hygiene", true) 3798 .Case("idiomatic-parentheses", true) 3799 .Case("ignored-qualifiers", true) 3800 .Case("implicit-atomic-properties", true) 3801 .Case("incompatible-pointer-types", true) 3802 .Case("incomplete-implementation", true) 3803 .Case("int-conversion", true) 3804 .Case("initializer-overrides", true) 3805 .Case("invalid-noreturn", true) 3806 .Case("invalid-token-paste", true) 3807 .Case("language-extension-token", true) 3808 .Case("literal-conversion", true) 3809 .Case("literal-range", true) 3810 .Case("local-type-template-args", true) 3811 .Case("logical-op-parentheses", true) 3812 .Case("method-signatures", true) 3813 .Case("microsoft", true) 3814 .Case("mismatched-tags", true) 3815 .Case("missing-method-return-type", true) 3816 .Case("non-pod-varargs", true) 3817 .Case("nonfragile-abi2", true) 3818 .Case("null-arithmetic", true) 3819 .Case("null-dereference", true) 3820 .Case("out-of-line-declaration", true) 3821 .Case("overriding-method-mismatch", true) 3822 .Case("readonly-setter-attrs", true) 3823 .Case("return-stack-address", true) 3824 .Case("self-assign", true) 3825 .Case("semicolon-before-method-body", true) 3826 .Case("sentinel", true) 3827 .Case("shift-overflow", true) 3828 .Case("shift-sign-overflow", true) 3829 .Case("sign-conversion", true) 3830 .Case("sizeof-array-argument", true) 3831 .Case("sizeof-pointer-memaccess", true) 3832 .Case("string-compare", true) 3833 .Case("super-class-method-mismatch", true) 3834 .Case("tautological-compare", true) 3835 .Case("typedef-redefinition", true) 3836 .Case("typename-missing", true) 3837 .Case("undefined-reinterpret-cast", true) 3838 .Case("unknown-warning-option", true) 3839 .Case("unnamed-type-template-args", true) 3840 .Case("unneeded-internal-declaration", true) 3841 .Case("unneeded-member-function", true) 3842 .Case("unused-comparison", true) 3843 .Case("unused-exception-parameter", true) 3844 .Case("unused-member-function", true) 3845 .Case("unused-result", true) 3846 .Case("vector-conversions", true) 3847 .Case("vla", true) 3848 .Case("used-but-marked-unused", true) 3849 .Case("weak-vtables", true) 3850 .Default(false); 3851 } // if (Option.startswith("-W")) 3852 if (RemoveOption) { 3853 it = CmdArgs.erase(it); 3854 ie = CmdArgs.end(); 3855 } else { 3856 ++it; 3857 } 3858 } 3859} 3860 3861void darwin::CC1::AddCC1Args(const ArgList &Args, 3862 ArgStringList &CmdArgs) const { 3863 const Driver &D = getToolChain().getDriver(); 3864 3865 CheckCodeGenerationOptions(D, Args); 3866 3867 // Derived from cc1 spec. 3868 if ((!Args.hasArg(options::OPT_mkernel) || 3869 (getDarwinToolChain().isTargetIPhoneOS() && 3870 !getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) && 3871 !Args.hasArg(options::OPT_static) && 3872 !Args.hasArg(options::OPT_mdynamic_no_pic)) 3873 CmdArgs.push_back("-fPIC"); 3874 3875 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 3876 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 3877 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 3878 CmdArgs.push_back("-fno-builtin-strcat"); 3879 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 3880 CmdArgs.push_back("-fno-builtin-strcpy"); 3881 } 3882 3883 if (Args.hasArg(options::OPT_g_Flag) && 3884 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 3885 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 3886} 3887 3888void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 3889 const InputInfoList &Inputs, 3890 const ArgStringList &OutputArgs) const { 3891 const Driver &D = getToolChain().getDriver(); 3892 3893 // Derived from cc1_options spec. 3894 if (Args.hasArg(options::OPT_fast) || 3895 Args.hasArg(options::OPT_fastf) || 3896 Args.hasArg(options::OPT_fastcp)) 3897 CmdArgs.push_back("-O3"); 3898 3899 if (Arg *A = Args.getLastArg(options::OPT_pg)) 3900 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 3901 D.Diag(diag::err_drv_argument_not_allowed_with) 3902 << A->getAsString(Args) << "-fomit-frame-pointer"; 3903 3904 AddCC1Args(Args, CmdArgs); 3905 3906 if (!Args.hasArg(options::OPT_Q)) 3907 CmdArgs.push_back("-quiet"); 3908 3909 CmdArgs.push_back("-dumpbase"); 3910 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 3911 3912 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 3913 3914 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 3915 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 3916 3917 // FIXME: The goal is to use the user provided -o if that is our 3918 // final output, otherwise to drive from the original input 3919 // name. Find a clean way to go about this. 3920 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 3921 Args.hasArg(options::OPT_o)) { 3922 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 3923 CmdArgs.push_back("-auxbase-strip"); 3924 CmdArgs.push_back(OutputOpt->getValue()); 3925 } else { 3926 CmdArgs.push_back("-auxbase"); 3927 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 3928 } 3929 3930 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 3931 3932 Args.AddAllArgs(CmdArgs, options::OPT_O); 3933 // FIXME: -Wall is getting some special treatment. Investigate. 3934 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 3935 Args.AddLastArg(CmdArgs, options::OPT_w); 3936 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 3937 options::OPT_trigraphs); 3938 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 3939 // Honor -std-default. 3940 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 3941 "-std=", /*Joined=*/true); 3942 } 3943 3944 if (Args.hasArg(options::OPT_v)) 3945 CmdArgs.push_back("-version"); 3946 if (Args.hasArg(options::OPT_pg) && 3947 getToolChain().SupportsProfiling()) 3948 CmdArgs.push_back("-p"); 3949 Args.AddLastArg(CmdArgs, options::OPT_p); 3950 3951 // The driver treats -fsyntax-only specially. 3952 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 3953 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 3954 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 3955 // used to inhibit the default -fno-builtin-str{cat,cpy}. 3956 // 3957 // FIXME: Should we grow a better way to deal with "removing" args? 3958 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group, 3959 options::OPT_fsyntax_only), 3960 ie = Args.filtered_end(); it != ie; ++it) { 3961 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) && 3962 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) { 3963 (*it)->claim(); 3964 (*it)->render(Args, CmdArgs); 3965 } 3966 } 3967 } else 3968 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 3969 3970 // Claim Clang only -f options, they aren't worth warning about. 3971 Args.ClaimAllArgs(options::OPT_f_clang_Group); 3972 3973 Args.AddAllArgs(CmdArgs, options::OPT_undef); 3974 if (Args.hasArg(options::OPT_Qn)) 3975 CmdArgs.push_back("-fno-ident"); 3976 3977 // FIXME: This isn't correct. 3978 //Args.AddLastArg(CmdArgs, options::OPT__help) 3979 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 3980 3981 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 3982 3983 // FIXME: Still don't get what is happening here. Investigate. 3984 Args.AddAllArgs(CmdArgs, options::OPT__param); 3985 3986 if (Args.hasArg(options::OPT_fmudflap) || 3987 Args.hasArg(options::OPT_fmudflapth)) { 3988 CmdArgs.push_back("-fno-builtin"); 3989 CmdArgs.push_back("-fno-merge-constants"); 3990 } 3991 3992 if (Args.hasArg(options::OPT_coverage)) { 3993 CmdArgs.push_back("-fprofile-arcs"); 3994 CmdArgs.push_back("-ftest-coverage"); 3995 } 3996 3997 if (types::isCXX(Inputs[0].getType())) 3998 CmdArgs.push_back("-D__private_extern__=extern"); 3999} 4000 4001void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 4002 const InputInfoList &Inputs, 4003 const ArgStringList &OutputArgs) const { 4004 // Derived from cpp_options 4005 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 4006 4007 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 4008 4009 AddCC1Args(Args, CmdArgs); 4010 4011 // NOTE: The code below has some commonality with cpp_options, but 4012 // in classic gcc style ends up sending things in different 4013 // orders. This may be a good merge candidate once we drop pedantic 4014 // compatibility. 4015 4016 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 4017 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 4018 options::OPT_trigraphs); 4019 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 4020 // Honor -std-default. 4021 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 4022 "-std=", /*Joined=*/true); 4023 } 4024 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 4025 Args.AddLastArg(CmdArgs, options::OPT_w); 4026 4027 // The driver treats -fsyntax-only specially. 4028 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 4029 4030 // Claim Clang only -f options, they aren't worth warning about. 4031 Args.ClaimAllArgs(options::OPT_f_clang_Group); 4032 4033 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 4034 !Args.hasArg(options::OPT_fno_working_directory)) 4035 CmdArgs.push_back("-fworking-directory"); 4036 4037 Args.AddAllArgs(CmdArgs, options::OPT_O); 4038 Args.AddAllArgs(CmdArgs, options::OPT_undef); 4039 if (Args.hasArg(options::OPT_save_temps)) 4040 CmdArgs.push_back("-fpch-preprocess"); 4041} 4042 4043void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 4044 ArgStringList &CmdArgs, 4045 const InputInfoList &Inputs) const { 4046 const Driver &D = getToolChain().getDriver(); 4047 4048 CheckPreprocessingOptions(D, Args); 4049 4050 // Derived from cpp_unique_options. 4051 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 4052 Args.AddLastArg(CmdArgs, options::OPT_C); 4053 Args.AddLastArg(CmdArgs, options::OPT_CC); 4054 if (!Args.hasArg(options::OPT_Q)) 4055 CmdArgs.push_back("-quiet"); 4056 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 4057 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx); 4058 Args.AddLastArg(CmdArgs, options::OPT_v); 4059 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 4060 Args.AddLastArg(CmdArgs, options::OPT_P); 4061 4062 // FIXME: Handle %I properly. 4063 if (getToolChain().getArch() == llvm::Triple::x86_64) { 4064 CmdArgs.push_back("-imultilib"); 4065 CmdArgs.push_back("x86_64"); 4066 } 4067 4068 if (Args.hasArg(options::OPT_MD)) { 4069 CmdArgs.push_back("-MD"); 4070 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 4071 } 4072 4073 if (Args.hasArg(options::OPT_MMD)) { 4074 CmdArgs.push_back("-MMD"); 4075 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 4076 } 4077 4078 Args.AddLastArg(CmdArgs, options::OPT_M); 4079 Args.AddLastArg(CmdArgs, options::OPT_MM); 4080 Args.AddAllArgs(CmdArgs, options::OPT_MF); 4081 Args.AddLastArg(CmdArgs, options::OPT_MG); 4082 Args.AddLastArg(CmdArgs, options::OPT_MP); 4083 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 4084 Args.AddAllArgs(CmdArgs, options::OPT_MT); 4085 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 4086 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 4087 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 4088 CmdArgs.push_back("-MQ"); 4089 CmdArgs.push_back(OutputOpt->getValue()); 4090 } 4091 } 4092 4093 Args.AddLastArg(CmdArgs, options::OPT_remap); 4094 if (Args.hasArg(options::OPT_g3)) 4095 CmdArgs.push_back("-dD"); 4096 Args.AddLastArg(CmdArgs, options::OPT_H); 4097 4098 AddCPPArgs(Args, CmdArgs); 4099 4100 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 4101 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 4102 4103 for (InputInfoList::const_iterator 4104 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4105 const InputInfo &II = *it; 4106 4107 CmdArgs.push_back(II.getFilename()); 4108 } 4109 4110 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 4111 options::OPT_Xpreprocessor); 4112 4113 if (Args.hasArg(options::OPT_fmudflap)) { 4114 CmdArgs.push_back("-D_MUDFLAP"); 4115 CmdArgs.push_back("-include"); 4116 CmdArgs.push_back("mf-runtime.h"); 4117 } 4118 4119 if (Args.hasArg(options::OPT_fmudflapth)) { 4120 CmdArgs.push_back("-D_MUDFLAP"); 4121 CmdArgs.push_back("-D_MUDFLAPTH"); 4122 CmdArgs.push_back("-include"); 4123 CmdArgs.push_back("mf-runtime.h"); 4124 } 4125} 4126 4127void darwin::CC1::AddCPPArgs(const ArgList &Args, 4128 ArgStringList &CmdArgs) const { 4129 // Derived from cpp spec. 4130 4131 if (Args.hasArg(options::OPT_static)) { 4132 // The gcc spec is broken here, it refers to dynamic but 4133 // that has been translated. Start by being bug compatible. 4134 4135 // if (!Args.hasArg(arglist.parser.dynamicOption)) 4136 CmdArgs.push_back("-D__STATIC__"); 4137 } else 4138 CmdArgs.push_back("-D__DYNAMIC__"); 4139 4140 if (Args.hasArg(options::OPT_pthread)) 4141 CmdArgs.push_back("-D_REENTRANT"); 4142} 4143 4144void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 4145 const InputInfo &Output, 4146 const InputInfoList &Inputs, 4147 const ArgList &Args, 4148 const char *LinkingOutput) const { 4149 ArgStringList CmdArgs; 4150 4151 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 4152 4153 CmdArgs.push_back("-E"); 4154 4155 if (Args.hasArg(options::OPT_traditional) || 4156 Args.hasArg(options::OPT_traditional_cpp)) 4157 CmdArgs.push_back("-traditional-cpp"); 4158 4159 ArgStringList OutputArgs; 4160 assert(Output.isFilename() && "Unexpected CC1 output."); 4161 OutputArgs.push_back("-o"); 4162 OutputArgs.push_back(Output.getFilename()); 4163 4164 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) { 4165 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 4166 } else { 4167 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 4168 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 4169 } 4170 4171 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 4172 4173 RemoveCC1UnsupportedArgs(CmdArgs); 4174 4175 const char *CC1Name = getCC1Name(Inputs[0].getType()); 4176 const char *Exec = 4177 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 4178 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4179} 4180 4181void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 4182 const InputInfo &Output, 4183 const InputInfoList &Inputs, 4184 const ArgList &Args, 4185 const char *LinkingOutput) const { 4186 const Driver &D = getToolChain().getDriver(); 4187 ArgStringList CmdArgs; 4188 4189 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 4190 4191 // Silence warning about unused --serialize-diagnostics 4192 Args.ClaimAllArgs(options::OPT__serialize_diags); 4193 4194 types::ID InputType = Inputs[0].getType(); 4195 if (const Arg *A = Args.getLastArg(options::OPT_traditional)) 4196 D.Diag(diag::err_drv_argument_only_allowed_with) 4197 << A->getAsString(Args) << "-E"; 4198 4199 if (JA.getType() == types::TY_LLVM_IR || 4200 JA.getType() == types::TY_LTO_IR) 4201 CmdArgs.push_back("-emit-llvm"); 4202 else if (JA.getType() == types::TY_LLVM_BC || 4203 JA.getType() == types::TY_LTO_BC) 4204 CmdArgs.push_back("-emit-llvm-bc"); 4205 else if (Output.getType() == types::TY_AST) 4206 D.Diag(diag::err_drv_no_ast_support) 4207 << getToolChain().getTripleString(); 4208 else if (JA.getType() != types::TY_PP_Asm && 4209 JA.getType() != types::TY_PCH) 4210 D.Diag(diag::err_drv_invalid_gcc_output_type) 4211 << getTypeName(JA.getType()); 4212 4213 ArgStringList OutputArgs; 4214 if (Output.getType() != types::TY_PCH) { 4215 OutputArgs.push_back("-o"); 4216 if (Output.isNothing()) 4217 OutputArgs.push_back("/dev/null"); 4218 else 4219 OutputArgs.push_back(Output.getFilename()); 4220 } 4221 4222 // There is no need for this level of compatibility, but it makes 4223 // diffing easier. 4224 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 4225 Args.hasArg(options::OPT_S)); 4226 4227 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 4228 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 4229 if (OutputArgsEarly) { 4230 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 4231 } else { 4232 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 4233 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 4234 } 4235 } else { 4236 CmdArgs.push_back("-fpreprocessed"); 4237 4238 for (InputInfoList::const_iterator 4239 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4240 const InputInfo &II = *it; 4241 4242 // Reject AST inputs. 4243 if (II.getType() == types::TY_AST) { 4244 D.Diag(diag::err_drv_no_ast_support) 4245 << getToolChain().getTripleString(); 4246 return; 4247 } 4248 4249 CmdArgs.push_back(II.getFilename()); 4250 } 4251 4252 if (OutputArgsEarly) { 4253 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 4254 } else { 4255 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 4256 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 4257 } 4258 } 4259 4260 if (Output.getType() == types::TY_PCH) { 4261 assert(Output.isFilename() && "Invalid PCH output."); 4262 4263 CmdArgs.push_back("-o"); 4264 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 4265 // to be a good reason. 4266 const char *TmpPath = C.getArgs().MakeArgString( 4267 D.GetTemporaryPath("cc", "s")); 4268 C.addTempFile(TmpPath); 4269 CmdArgs.push_back(TmpPath); 4270 4271 // If we're emitting a pch file with the last 4 characters of ".pth" 4272 // and falling back to llvm-gcc we want to use ".gch" instead. 4273 std::string OutputFile(Output.getFilename()); 4274 size_t loc = OutputFile.rfind(".pth"); 4275 if (loc != std::string::npos) 4276 OutputFile.replace(loc, 4, ".gch"); 4277 const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile); 4278 CmdArgs.push_back(Tmp); 4279 } 4280 4281 RemoveCC1UnsupportedArgs(CmdArgs); 4282 4283 const char *CC1Name = getCC1Name(Inputs[0].getType()); 4284 const char *Exec = 4285 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 4286 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4287} 4288 4289void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4290 const InputInfo &Output, 4291 const InputInfoList &Inputs, 4292 const ArgList &Args, 4293 const char *LinkingOutput) const { 4294 ArgStringList CmdArgs; 4295 4296 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 4297 const InputInfo &Input = Inputs[0]; 4298 4299 // Determine the original source input. 4300 const Action *SourceAction = &JA; 4301 while (SourceAction->getKind() != Action::InputClass) { 4302 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 4303 SourceAction = SourceAction->getInputs()[0]; 4304 } 4305 4306 // Forward -g, assuming we are dealing with an actual assembly file. 4307 if (SourceAction->getType() == types::TY_Asm || 4308 SourceAction->getType() == types::TY_PP_Asm) { 4309 if (Args.hasArg(options::OPT_gstabs)) 4310 CmdArgs.push_back("--gstabs"); 4311 else if (Args.hasArg(options::OPT_g_Group)) 4312 CmdArgs.push_back("-g"); 4313 } 4314 4315 // Derived from asm spec. 4316 AddDarwinArch(Args, CmdArgs); 4317 4318 // Use -force_cpusubtype_ALL on x86 by default. 4319 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 || 4320 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 || 4321 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 4322 CmdArgs.push_back("-force_cpusubtype_ALL"); 4323 4324 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 4325 (((Args.hasArg(options::OPT_mkernel) || 4326 Args.hasArg(options::OPT_fapple_kext)) && 4327 (!getDarwinToolChain().isTargetIPhoneOS() || 4328 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) || 4329 Args.hasArg(options::OPT_static))) 4330 CmdArgs.push_back("-static"); 4331 4332 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4333 options::OPT_Xassembler); 4334 4335 assert(Output.isFilename() && "Unexpected lipo output."); 4336 CmdArgs.push_back("-o"); 4337 CmdArgs.push_back(Output.getFilename()); 4338 4339 assert(Input.isFilename() && "Invalid input."); 4340 CmdArgs.push_back(Input.getFilename()); 4341 4342 // asm_final spec is empty. 4343 4344 const char *Exec = 4345 Args.MakeArgString(getToolChain().GetProgramPath("as")); 4346 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4347} 4348 4349void darwin::DarwinTool::anchor() {} 4350 4351void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 4352 ArgStringList &CmdArgs) const { 4353 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 4354 4355 // Derived from darwin_arch spec. 4356 CmdArgs.push_back("-arch"); 4357 CmdArgs.push_back(Args.MakeArgString(ArchName)); 4358 4359 // FIXME: Is this needed anymore? 4360 if (ArchName == "arm") 4361 CmdArgs.push_back("-force_cpusubtype_ALL"); 4362} 4363 4364bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const { 4365 // We only need to generate a temp path for LTO if we aren't compiling object 4366 // files. When compiling source files, we run 'dsymutil' after linking. We 4367 // don't run 'dsymutil' when compiling object files. 4368 for (InputInfoList::const_iterator 4369 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) 4370 if (it->getType() != types::TY_Object) 4371 return true; 4372 4373 return false; 4374} 4375 4376void darwin::Link::AddLinkArgs(Compilation &C, 4377 const ArgList &Args, 4378 ArgStringList &CmdArgs, 4379 const InputInfoList &Inputs) const { 4380 const Driver &D = getToolChain().getDriver(); 4381 const toolchains::Darwin &DarwinTC = getDarwinToolChain(); 4382 4383 unsigned Version[3] = { 0, 0, 0 }; 4384 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 4385 bool HadExtra; 4386 if (!Driver::GetReleaseVersion(A->getValue(), Version[0], 4387 Version[1], Version[2], HadExtra) || 4388 HadExtra) 4389 D.Diag(diag::err_drv_invalid_version_number) 4390 << A->getAsString(Args); 4391 } 4392 4393 // Newer linkers support -demangle, pass it if supported and not disabled by 4394 // the user. 4395 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) { 4396 // Don't pass -demangle to ld_classic. 4397 // 4398 // FIXME: This is a temporary workaround, ld should be handling this. 4399 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 && 4400 Args.hasArg(options::OPT_static)); 4401 if (getToolChain().getArch() == llvm::Triple::x86) { 4402 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker, 4403 options::OPT_Wl_COMMA), 4404 ie = Args.filtered_end(); it != ie; ++it) { 4405 const Arg *A = *it; 4406 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 4407 if (StringRef(A->getValue(i)) == "-kext") 4408 UsesLdClassic = true; 4409 } 4410 } 4411 if (!UsesLdClassic) 4412 CmdArgs.push_back("-demangle"); 4413 } 4414 4415 // If we are using LTO, then automatically create a temporary file path for 4416 // the linker to use, so that it's lifetime will extend past a possible 4417 // dsymutil step. 4418 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) { 4419 const char *TmpPath = C.getArgs().MakeArgString( 4420 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); 4421 C.addTempFile(TmpPath); 4422 CmdArgs.push_back("-object_path_lto"); 4423 CmdArgs.push_back(TmpPath); 4424 } 4425 4426 // Derived from the "link" spec. 4427 Args.AddAllArgs(CmdArgs, options::OPT_static); 4428 if (!Args.hasArg(options::OPT_static)) 4429 CmdArgs.push_back("-dynamic"); 4430 if (Args.hasArg(options::OPT_fgnu_runtime)) { 4431 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 4432 // here. How do we wish to handle such things? 4433 } 4434 4435 if (!Args.hasArg(options::OPT_dynamiclib)) { 4436 AddDarwinArch(Args, CmdArgs); 4437 // FIXME: Why do this only on this path? 4438 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 4439 4440 Args.AddLastArg(CmdArgs, options::OPT_bundle); 4441 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 4442 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 4443 4444 Arg *A; 4445 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 4446 (A = Args.getLastArg(options::OPT_current__version)) || 4447 (A = Args.getLastArg(options::OPT_install__name))) 4448 D.Diag(diag::err_drv_argument_only_allowed_with) 4449 << A->getAsString(Args) << "-dynamiclib"; 4450 4451 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 4452 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 4453 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 4454 } else { 4455 CmdArgs.push_back("-dylib"); 4456 4457 Arg *A; 4458 if ((A = Args.getLastArg(options::OPT_bundle)) || 4459 (A = Args.getLastArg(options::OPT_bundle__loader)) || 4460 (A = Args.getLastArg(options::OPT_client__name)) || 4461 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 4462 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 4463 (A = Args.getLastArg(options::OPT_private__bundle))) 4464 D.Diag(diag::err_drv_argument_not_allowed_with) 4465 << A->getAsString(Args) << "-dynamiclib"; 4466 4467 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 4468 "-dylib_compatibility_version"); 4469 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 4470 "-dylib_current_version"); 4471 4472 AddDarwinArch(Args, CmdArgs); 4473 4474 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 4475 "-dylib_install_name"); 4476 } 4477 4478 Args.AddLastArg(CmdArgs, options::OPT_all__load); 4479 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 4480 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 4481 if (DarwinTC.isTargetIPhoneOS()) 4482 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 4483 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 4484 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 4485 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 4486 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 4487 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 4488 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 4489 Args.AddAllArgs(CmdArgs, options::OPT_force__load); 4490 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 4491 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 4492 Args.AddAllArgs(CmdArgs, options::OPT_init); 4493 4494 // Add the deployment target. 4495 VersionTuple TargetVersion = DarwinTC.getTargetVersion(); 4496 4497 // If we had an explicit -mios-simulator-version-min argument, honor that, 4498 // otherwise use the traditional deployment targets. We can't just check the 4499 // is-sim attribute because existing code follows this path, and the linker 4500 // may not handle the argument. 4501 // 4502 // FIXME: We may be able to remove this, once we can verify no one depends on 4503 // it. 4504 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ)) 4505 CmdArgs.push_back("-ios_simulator_version_min"); 4506 else if (DarwinTC.isTargetIPhoneOS()) 4507 CmdArgs.push_back("-iphoneos_version_min"); 4508 else 4509 CmdArgs.push_back("-macosx_version_min"); 4510 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString())); 4511 4512 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 4513 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 4514 Args.AddLastArg(CmdArgs, options::OPT_single__module); 4515 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 4516 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 4517 4518 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, 4519 options::OPT_fno_pie, 4520 options::OPT_fno_PIE)) { 4521 if (A->getOption().matches(options::OPT_fpie) || 4522 A->getOption().matches(options::OPT_fPIE)) 4523 CmdArgs.push_back("-pie"); 4524 else 4525 CmdArgs.push_back("-no_pie"); 4526 } 4527 4528 Args.AddLastArg(CmdArgs, options::OPT_prebind); 4529 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 4530 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 4531 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 4532 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 4533 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 4534 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 4535 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 4536 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 4537 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 4538 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 4539 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 4540 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 4541 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 4542 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 4543 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 4544 4545 // Give --sysroot= preference, over the Apple specific behavior to also use 4546 // --isysroot as the syslibroot. 4547 StringRef sysroot = C.getSysRoot(); 4548 if (sysroot != "") { 4549 CmdArgs.push_back("-syslibroot"); 4550 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 4551 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 4552 CmdArgs.push_back("-syslibroot"); 4553 CmdArgs.push_back(A->getValue()); 4554 } 4555 4556 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 4557 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 4558 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 4559 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 4560 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 4561 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 4562 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 4563 Args.AddAllArgs(CmdArgs, options::OPT_y); 4564 Args.AddLastArg(CmdArgs, options::OPT_w); 4565 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 4566 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 4567 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 4568 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 4569 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 4570 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 4571 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 4572 Args.AddLastArg(CmdArgs, options::OPT_whyload); 4573 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 4574 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 4575 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 4576 Args.AddLastArg(CmdArgs, options::OPT_Mach); 4577} 4578 4579void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 4580 const InputInfo &Output, 4581 const InputInfoList &Inputs, 4582 const ArgList &Args, 4583 const char *LinkingOutput) const { 4584 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 4585 4586 // The logic here is derived from gcc's behavior; most of which 4587 // comes from specs (starting with link_command). Consult gcc for 4588 // more information. 4589 ArgStringList CmdArgs; 4590 4591 /// Hack(tm) to ignore linking errors when we are doing ARC migration. 4592 if (Args.hasArg(options::OPT_ccc_arcmt_check, 4593 options::OPT_ccc_arcmt_migrate)) { 4594 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) 4595 (*I)->claim(); 4596 const char *Exec = 4597 Args.MakeArgString(getToolChain().GetProgramPath("touch")); 4598 CmdArgs.push_back(Output.getFilename()); 4599 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4600 return; 4601 } 4602 4603 // I'm not sure why this particular decomposition exists in gcc, but 4604 // we follow suite for ease of comparison. 4605 AddLinkArgs(C, Args, CmdArgs, Inputs); 4606 4607 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 4608 Args.AddAllArgs(CmdArgs, options::OPT_s); 4609 Args.AddAllArgs(CmdArgs, options::OPT_t); 4610 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 4611 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 4612 Args.AddLastArg(CmdArgs, options::OPT_e); 4613 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 4614 Args.AddAllArgs(CmdArgs, options::OPT_r); 4615 4616 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading 4617 // members of static archive libraries which implement Objective-C classes or 4618 // categories. 4619 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX)) 4620 CmdArgs.push_back("-ObjC"); 4621 4622 CmdArgs.push_back("-o"); 4623 CmdArgs.push_back(Output.getFilename()); 4624 4625 if (!Args.hasArg(options::OPT_nostdlib) && 4626 !Args.hasArg(options::OPT_nostartfiles)) { 4627 // Derived from startfile spec. 4628 if (Args.hasArg(options::OPT_dynamiclib)) { 4629 // Derived from darwin_dylib1 spec. 4630 if (getDarwinToolChain().isTargetIOSSimulator()) { 4631 // The simulator doesn't have a versioned crt1 file. 4632 CmdArgs.push_back("-ldylib1.o"); 4633 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 4634 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 4635 CmdArgs.push_back("-ldylib1.o"); 4636 } else { 4637 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 4638 CmdArgs.push_back("-ldylib1.o"); 4639 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 4640 CmdArgs.push_back("-ldylib1.10.5.o"); 4641 } 4642 } else { 4643 if (Args.hasArg(options::OPT_bundle)) { 4644 if (!Args.hasArg(options::OPT_static)) { 4645 // Derived from darwin_bundle1 spec. 4646 if (getDarwinToolChain().isTargetIOSSimulator()) { 4647 // The simulator doesn't have a versioned crt1 file. 4648 CmdArgs.push_back("-lbundle1.o"); 4649 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 4650 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 4651 CmdArgs.push_back("-lbundle1.o"); 4652 } else { 4653 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 4654 CmdArgs.push_back("-lbundle1.o"); 4655 } 4656 } 4657 } else { 4658 if (Args.hasArg(options::OPT_pg) && 4659 getToolChain().SupportsProfiling()) { 4660 if (Args.hasArg(options::OPT_static) || 4661 Args.hasArg(options::OPT_object) || 4662 Args.hasArg(options::OPT_preload)) { 4663 CmdArgs.push_back("-lgcrt0.o"); 4664 } else { 4665 CmdArgs.push_back("-lgcrt1.o"); 4666 4667 // darwin_crt2 spec is empty. 4668 } 4669 // By default on OS X 10.8 and later, we don't link with a crt1.o 4670 // file and the linker knows to use _main as the entry point. But, 4671 // when compiling with -pg, we need to link with the gcrt1.o file, 4672 // so pass the -no_new_main option to tell the linker to use the 4673 // "start" symbol as the entry point. 4674 if (getDarwinToolChain().isTargetMacOS() && 4675 !getDarwinToolChain().isMacosxVersionLT(10, 8)) 4676 CmdArgs.push_back("-no_new_main"); 4677 } else { 4678 if (Args.hasArg(options::OPT_static) || 4679 Args.hasArg(options::OPT_object) || 4680 Args.hasArg(options::OPT_preload)) { 4681 CmdArgs.push_back("-lcrt0.o"); 4682 } else { 4683 // Derived from darwin_crt1 spec. 4684 if (getDarwinToolChain().isTargetIOSSimulator()) { 4685 // The simulator doesn't have a versioned crt1 file. 4686 CmdArgs.push_back("-lcrt1.o"); 4687 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 4688 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 4689 CmdArgs.push_back("-lcrt1.o"); 4690 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0)) 4691 CmdArgs.push_back("-lcrt1.3.1.o"); 4692 } else { 4693 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 4694 CmdArgs.push_back("-lcrt1.o"); 4695 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 4696 CmdArgs.push_back("-lcrt1.10.5.o"); 4697 else if (getDarwinToolChain().isMacosxVersionLT(10, 8)) 4698 CmdArgs.push_back("-lcrt1.10.6.o"); 4699 4700 // darwin_crt2 spec is empty. 4701 } 4702 } 4703 } 4704 } 4705 } 4706 4707 if (!getDarwinToolChain().isTargetIPhoneOS() && 4708 Args.hasArg(options::OPT_shared_libgcc) && 4709 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 4710 const char *Str = 4711 Args.MakeArgString(getToolChain().GetFilePath("crt3.o")); 4712 CmdArgs.push_back(Str); 4713 } 4714 } 4715 4716 Args.AddAllArgs(CmdArgs, options::OPT_L); 4717 4718 SanitizerArgs Sanitize(getToolChain().getDriver(), Args); 4719 // If we're building a dynamic lib with -fsanitize=address, or 4720 // -fsanitize=undefined, unresolved symbols may appear. Mark all 4721 // of them as dynamic_lookup. Linking executables is handled in 4722 // lib/Driver/ToolChains.cpp. 4723 if (Sanitize.needsAsanRt() || Sanitize.needsUbsanRt()) { 4724 if (Args.hasArg(options::OPT_dynamiclib) || 4725 Args.hasArg(options::OPT_bundle)) { 4726 CmdArgs.push_back("-undefined"); 4727 CmdArgs.push_back("dynamic_lookup"); 4728 } 4729 } 4730 4731 if (Args.hasArg(options::OPT_fopenmp)) 4732 // This is more complicated in gcc... 4733 CmdArgs.push_back("-lgomp"); 4734 4735 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4736 4737 if (isObjCRuntimeLinked(Args) && 4738 !Args.hasArg(options::OPT_nostdlib) && 4739 !Args.hasArg(options::OPT_nodefaultlibs)) { 4740 // Avoid linking compatibility stubs on i386 mac. 4741 if (!getDarwinToolChain().isTargetMacOS() || 4742 getDarwinToolChain().getArch() != llvm::Triple::x86) { 4743 // If we don't have ARC or subscripting runtime support, link in the 4744 // runtime stubs. We have to do this *before* adding any of the normal 4745 // linker inputs so that its initializer gets run first. 4746 ObjCRuntime runtime = 4747 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true); 4748 // We use arclite library for both ARC and subscripting support. 4749 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) || 4750 !runtime.hasSubscripting()) 4751 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs); 4752 } 4753 CmdArgs.push_back("-framework"); 4754 CmdArgs.push_back("Foundation"); 4755 // Link libobj. 4756 CmdArgs.push_back("-lobjc"); 4757 } 4758 4759 if (LinkingOutput) { 4760 CmdArgs.push_back("-arch_multiple"); 4761 CmdArgs.push_back("-final_output"); 4762 CmdArgs.push_back(LinkingOutput); 4763 } 4764 4765 if (Args.hasArg(options::OPT_fnested_functions)) 4766 CmdArgs.push_back("-allow_stack_execute"); 4767 4768 if (!Args.hasArg(options::OPT_nostdlib) && 4769 !Args.hasArg(options::OPT_nodefaultlibs)) { 4770 if (getToolChain().getDriver().CCCIsCXX) 4771 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 4772 4773 // link_ssp spec is empty. 4774 4775 // Let the tool chain choose which runtime library to link. 4776 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 4777 } 4778 4779 if (!Args.hasArg(options::OPT_nostdlib) && 4780 !Args.hasArg(options::OPT_nostartfiles)) { 4781 // endfile_spec is empty. 4782 } 4783 4784 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4785 Args.AddAllArgs(CmdArgs, options::OPT_F); 4786 4787 const char *Exec = 4788 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 4789 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4790} 4791 4792void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 4793 const InputInfo &Output, 4794 const InputInfoList &Inputs, 4795 const ArgList &Args, 4796 const char *LinkingOutput) const { 4797 ArgStringList CmdArgs; 4798 4799 CmdArgs.push_back("-create"); 4800 assert(Output.isFilename() && "Unexpected lipo output."); 4801 4802 CmdArgs.push_back("-output"); 4803 CmdArgs.push_back(Output.getFilename()); 4804 4805 for (InputInfoList::const_iterator 4806 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4807 const InputInfo &II = *it; 4808 assert(II.isFilename() && "Unexpected lipo input."); 4809 CmdArgs.push_back(II.getFilename()); 4810 } 4811 const char *Exec = 4812 Args.MakeArgString(getToolChain().GetProgramPath("lipo")); 4813 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4814} 4815 4816void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, 4817 const InputInfo &Output, 4818 const InputInfoList &Inputs, 4819 const ArgList &Args, 4820 const char *LinkingOutput) const { 4821 ArgStringList CmdArgs; 4822 4823 CmdArgs.push_back("-o"); 4824 CmdArgs.push_back(Output.getFilename()); 4825 4826 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 4827 const InputInfo &Input = Inputs[0]; 4828 assert(Input.isFilename() && "Unexpected dsymutil input."); 4829 CmdArgs.push_back(Input.getFilename()); 4830 4831 const char *Exec = 4832 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); 4833 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4834} 4835 4836void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA, 4837 const InputInfo &Output, 4838 const InputInfoList &Inputs, 4839 const ArgList &Args, 4840 const char *LinkingOutput) const { 4841 ArgStringList CmdArgs; 4842 CmdArgs.push_back("--verify"); 4843 CmdArgs.push_back("--debug-info"); 4844 CmdArgs.push_back("--eh-frame"); 4845 CmdArgs.push_back("--quiet"); 4846 4847 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 4848 const InputInfo &Input = Inputs[0]; 4849 assert(Input.isFilename() && "Unexpected verify input"); 4850 4851 // Grabbing the output of the earlier dsymutil run. 4852 CmdArgs.push_back(Input.getFilename()); 4853 4854 const char *Exec = 4855 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); 4856 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4857} 4858 4859void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4860 const InputInfo &Output, 4861 const InputInfoList &Inputs, 4862 const ArgList &Args, 4863 const char *LinkingOutput) const { 4864 ArgStringList CmdArgs; 4865 4866 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4867 options::OPT_Xassembler); 4868 4869 CmdArgs.push_back("-o"); 4870 CmdArgs.push_back(Output.getFilename()); 4871 4872 for (InputInfoList::const_iterator 4873 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4874 const InputInfo &II = *it; 4875 CmdArgs.push_back(II.getFilename()); 4876 } 4877 4878 const char *Exec = 4879 Args.MakeArgString(getToolChain().GetProgramPath("as")); 4880 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4881} 4882 4883 4884void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA, 4885 const InputInfo &Output, 4886 const InputInfoList &Inputs, 4887 const ArgList &Args, 4888 const char *LinkingOutput) const { 4889 // FIXME: Find a real GCC, don't hard-code versions here 4890 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/"; 4891 const llvm::Triple &T = getToolChain().getTriple(); 4892 std::string LibPath = "/usr/lib/"; 4893 llvm::Triple::ArchType Arch = T.getArch(); 4894 switch (Arch) { 4895 case llvm::Triple::x86: 4896 GCCLibPath += ("i386-" + T.getVendorName() + "-" + 4897 T.getOSName()).str() + "/4.5.2/"; 4898 break; 4899 case llvm::Triple::x86_64: 4900 GCCLibPath += ("i386-" + T.getVendorName() + "-" + 4901 T.getOSName()).str(); 4902 GCCLibPath += "/4.5.2/amd64/"; 4903 LibPath += "amd64/"; 4904 break; 4905 default: 4906 assert(0 && "Unsupported architecture"); 4907 } 4908 4909 ArgStringList CmdArgs; 4910 4911 // Demangle C++ names in errors 4912 CmdArgs.push_back("-C"); 4913 4914 if ((!Args.hasArg(options::OPT_nostdlib)) && 4915 (!Args.hasArg(options::OPT_shared))) { 4916 CmdArgs.push_back("-e"); 4917 CmdArgs.push_back("_start"); 4918 } 4919 4920 if (Args.hasArg(options::OPT_static)) { 4921 CmdArgs.push_back("-Bstatic"); 4922 CmdArgs.push_back("-dn"); 4923 } else { 4924 CmdArgs.push_back("-Bdynamic"); 4925 if (Args.hasArg(options::OPT_shared)) { 4926 CmdArgs.push_back("-shared"); 4927 } else { 4928 CmdArgs.push_back("--dynamic-linker"); 4929 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1")); 4930 } 4931 } 4932 4933 if (Output.isFilename()) { 4934 CmdArgs.push_back("-o"); 4935 CmdArgs.push_back(Output.getFilename()); 4936 } else { 4937 assert(Output.isNothing() && "Invalid output."); 4938 } 4939 4940 if (!Args.hasArg(options::OPT_nostdlib) && 4941 !Args.hasArg(options::OPT_nostartfiles)) { 4942 if (!Args.hasArg(options::OPT_shared)) { 4943 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o")); 4944 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); 4945 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); 4946 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); 4947 } else { 4948 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); 4949 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); 4950 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); 4951 } 4952 if (getToolChain().getDriver().CCCIsCXX) 4953 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o")); 4954 } 4955 4956 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath)); 4957 4958 Args.AddAllArgs(CmdArgs, options::OPT_L); 4959 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4960 Args.AddAllArgs(CmdArgs, options::OPT_e); 4961 Args.AddAllArgs(CmdArgs, options::OPT_r); 4962 4963 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4964 4965 if (!Args.hasArg(options::OPT_nostdlib) && 4966 !Args.hasArg(options::OPT_nodefaultlibs)) { 4967 if (getToolChain().getDriver().CCCIsCXX) 4968 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 4969 CmdArgs.push_back("-lgcc_s"); 4970 if (!Args.hasArg(options::OPT_shared)) { 4971 CmdArgs.push_back("-lgcc"); 4972 CmdArgs.push_back("-lc"); 4973 CmdArgs.push_back("-lm"); 4974 } 4975 } 4976 4977 if (!Args.hasArg(options::OPT_nostdlib) && 4978 !Args.hasArg(options::OPT_nostartfiles)) { 4979 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o")); 4980 } 4981 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o")); 4982 4983 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4984 4985 const char *Exec = 4986 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 4987 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4988} 4989 4990void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4991 const InputInfo &Output, 4992 const InputInfoList &Inputs, 4993 const ArgList &Args, 4994 const char *LinkingOutput) const { 4995 ArgStringList CmdArgs; 4996 4997 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4998 options::OPT_Xassembler); 4999 5000 CmdArgs.push_back("-o"); 5001 CmdArgs.push_back(Output.getFilename()); 5002 5003 for (InputInfoList::const_iterator 5004 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5005 const InputInfo &II = *it; 5006 CmdArgs.push_back(II.getFilename()); 5007 } 5008 5009 const char *Exec = 5010 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 5011 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5012} 5013 5014void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 5015 const InputInfo &Output, 5016 const InputInfoList &Inputs, 5017 const ArgList &Args, 5018 const char *LinkingOutput) const { 5019 ArgStringList CmdArgs; 5020 5021 if ((!Args.hasArg(options::OPT_nostdlib)) && 5022 (!Args.hasArg(options::OPT_shared))) { 5023 CmdArgs.push_back("-e"); 5024 CmdArgs.push_back("_start"); 5025 } 5026 5027 if (Args.hasArg(options::OPT_static)) { 5028 CmdArgs.push_back("-Bstatic"); 5029 CmdArgs.push_back("-dn"); 5030 } else { 5031// CmdArgs.push_back("--eh-frame-hdr"); 5032 CmdArgs.push_back("-Bdynamic"); 5033 if (Args.hasArg(options::OPT_shared)) { 5034 CmdArgs.push_back("-shared"); 5035 } else { 5036 CmdArgs.push_back("--dynamic-linker"); 5037 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 5038 } 5039 } 5040 5041 if (Output.isFilename()) { 5042 CmdArgs.push_back("-o"); 5043 CmdArgs.push_back(Output.getFilename()); 5044 } else { 5045 assert(Output.isNothing() && "Invalid output."); 5046 } 5047 5048 if (!Args.hasArg(options::OPT_nostdlib) && 5049 !Args.hasArg(options::OPT_nostartfiles)) { 5050 if (!Args.hasArg(options::OPT_shared)) { 5051 CmdArgs.push_back(Args.MakeArgString( 5052 getToolChain().GetFilePath("crt1.o"))); 5053 CmdArgs.push_back(Args.MakeArgString( 5054 getToolChain().GetFilePath("crti.o"))); 5055 CmdArgs.push_back(Args.MakeArgString( 5056 getToolChain().GetFilePath("crtbegin.o"))); 5057 } else { 5058 CmdArgs.push_back(Args.MakeArgString( 5059 getToolChain().GetFilePath("crti.o"))); 5060 } 5061 CmdArgs.push_back(Args.MakeArgString( 5062 getToolChain().GetFilePath("crtn.o"))); 5063 } 5064 5065 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 5066 + getToolChain().getTripleString() 5067 + "/4.2.4")); 5068 5069 Args.AddAllArgs(CmdArgs, options::OPT_L); 5070 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5071 Args.AddAllArgs(CmdArgs, options::OPT_e); 5072 5073 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5074 5075 if (!Args.hasArg(options::OPT_nostdlib) && 5076 !Args.hasArg(options::OPT_nodefaultlibs)) { 5077 // FIXME: For some reason GCC passes -lgcc before adding 5078 // the default system libraries. Just mimic this for now. 5079 CmdArgs.push_back("-lgcc"); 5080 5081 if (Args.hasArg(options::OPT_pthread)) 5082 CmdArgs.push_back("-pthread"); 5083 if (!Args.hasArg(options::OPT_shared)) 5084 CmdArgs.push_back("-lc"); 5085 CmdArgs.push_back("-lgcc"); 5086 } 5087 5088 if (!Args.hasArg(options::OPT_nostdlib) && 5089 !Args.hasArg(options::OPT_nostartfiles)) { 5090 if (!Args.hasArg(options::OPT_shared)) 5091 CmdArgs.push_back(Args.MakeArgString( 5092 getToolChain().GetFilePath("crtend.o"))); 5093 } 5094 5095 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 5096 5097 const char *Exec = 5098 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5099 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5100} 5101 5102void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5103 const InputInfo &Output, 5104 const InputInfoList &Inputs, 5105 const ArgList &Args, 5106 const char *LinkingOutput) const { 5107 ArgStringList CmdArgs; 5108 5109 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5110 options::OPT_Xassembler); 5111 5112 CmdArgs.push_back("-o"); 5113 CmdArgs.push_back(Output.getFilename()); 5114 5115 for (InputInfoList::const_iterator 5116 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5117 const InputInfo &II = *it; 5118 CmdArgs.push_back(II.getFilename()); 5119 } 5120 5121 const char *Exec = 5122 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5123 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5124} 5125 5126void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 5127 const InputInfo &Output, 5128 const InputInfoList &Inputs, 5129 const ArgList &Args, 5130 const char *LinkingOutput) const { 5131 const Driver &D = getToolChain().getDriver(); 5132 ArgStringList CmdArgs; 5133 5134 if ((!Args.hasArg(options::OPT_nostdlib)) && 5135 (!Args.hasArg(options::OPT_shared))) { 5136 CmdArgs.push_back("-e"); 5137 CmdArgs.push_back("__start"); 5138 } 5139 5140 if (Args.hasArg(options::OPT_static)) { 5141 CmdArgs.push_back("-Bstatic"); 5142 } else { 5143 if (Args.hasArg(options::OPT_rdynamic)) 5144 CmdArgs.push_back("-export-dynamic"); 5145 CmdArgs.push_back("--eh-frame-hdr"); 5146 CmdArgs.push_back("-Bdynamic"); 5147 if (Args.hasArg(options::OPT_shared)) { 5148 CmdArgs.push_back("-shared"); 5149 } else { 5150 CmdArgs.push_back("-dynamic-linker"); 5151 CmdArgs.push_back("/usr/libexec/ld.so"); 5152 } 5153 } 5154 5155 if (Output.isFilename()) { 5156 CmdArgs.push_back("-o"); 5157 CmdArgs.push_back(Output.getFilename()); 5158 } else { 5159 assert(Output.isNothing() && "Invalid output."); 5160 } 5161 5162 if (!Args.hasArg(options::OPT_nostdlib) && 5163 !Args.hasArg(options::OPT_nostartfiles)) { 5164 if (!Args.hasArg(options::OPT_shared)) { 5165 if (Args.hasArg(options::OPT_pg)) 5166 CmdArgs.push_back(Args.MakeArgString( 5167 getToolChain().GetFilePath("gcrt0.o"))); 5168 else 5169 CmdArgs.push_back(Args.MakeArgString( 5170 getToolChain().GetFilePath("crt0.o"))); 5171 CmdArgs.push_back(Args.MakeArgString( 5172 getToolChain().GetFilePath("crtbegin.o"))); 5173 } else { 5174 CmdArgs.push_back(Args.MakeArgString( 5175 getToolChain().GetFilePath("crtbeginS.o"))); 5176 } 5177 } 5178 5179 std::string Triple = getToolChain().getTripleString(); 5180 if (Triple.substr(0, 6) == "x86_64") 5181 Triple.replace(0, 6, "amd64"); 5182 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 5183 "/4.2.1")); 5184 5185 Args.AddAllArgs(CmdArgs, options::OPT_L); 5186 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5187 Args.AddAllArgs(CmdArgs, options::OPT_e); 5188 5189 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5190 5191 if (!Args.hasArg(options::OPT_nostdlib) && 5192 !Args.hasArg(options::OPT_nodefaultlibs)) { 5193 if (D.CCCIsCXX) { 5194 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5195 if (Args.hasArg(options::OPT_pg)) 5196 CmdArgs.push_back("-lm_p"); 5197 else 5198 CmdArgs.push_back("-lm"); 5199 } 5200 5201 // FIXME: For some reason GCC passes -lgcc before adding 5202 // the default system libraries. Just mimic this for now. 5203 CmdArgs.push_back("-lgcc"); 5204 5205 if (Args.hasArg(options::OPT_pthread)) { 5206 if (!Args.hasArg(options::OPT_shared) && 5207 Args.hasArg(options::OPT_pg)) 5208 CmdArgs.push_back("-lpthread_p"); 5209 else 5210 CmdArgs.push_back("-lpthread"); 5211 } 5212 5213 if (!Args.hasArg(options::OPT_shared)) { 5214 if (Args.hasArg(options::OPT_pg)) 5215 CmdArgs.push_back("-lc_p"); 5216 else 5217 CmdArgs.push_back("-lc"); 5218 } 5219 5220 CmdArgs.push_back("-lgcc"); 5221 } 5222 5223 if (!Args.hasArg(options::OPT_nostdlib) && 5224 !Args.hasArg(options::OPT_nostartfiles)) { 5225 if (!Args.hasArg(options::OPT_shared)) 5226 CmdArgs.push_back(Args.MakeArgString( 5227 getToolChain().GetFilePath("crtend.o"))); 5228 else 5229 CmdArgs.push_back(Args.MakeArgString( 5230 getToolChain().GetFilePath("crtendS.o"))); 5231 } 5232 5233 const char *Exec = 5234 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5235 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5236} 5237 5238void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5239 const InputInfo &Output, 5240 const InputInfoList &Inputs, 5241 const ArgList &Args, 5242 const char *LinkingOutput) const { 5243 ArgStringList CmdArgs; 5244 5245 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5246 options::OPT_Xassembler); 5247 5248 CmdArgs.push_back("-o"); 5249 CmdArgs.push_back(Output.getFilename()); 5250 5251 for (InputInfoList::const_iterator 5252 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5253 const InputInfo &II = *it; 5254 CmdArgs.push_back(II.getFilename()); 5255 } 5256 5257 const char *Exec = 5258 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5259 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5260} 5261 5262void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, 5263 const InputInfo &Output, 5264 const InputInfoList &Inputs, 5265 const ArgList &Args, 5266 const char *LinkingOutput) const { 5267 const Driver &D = getToolChain().getDriver(); 5268 ArgStringList CmdArgs; 5269 5270 if ((!Args.hasArg(options::OPT_nostdlib)) && 5271 (!Args.hasArg(options::OPT_shared))) { 5272 CmdArgs.push_back("-e"); 5273 CmdArgs.push_back("__start"); 5274 } 5275 5276 if (Args.hasArg(options::OPT_static)) { 5277 CmdArgs.push_back("-Bstatic"); 5278 } else { 5279 if (Args.hasArg(options::OPT_rdynamic)) 5280 CmdArgs.push_back("-export-dynamic"); 5281 CmdArgs.push_back("--eh-frame-hdr"); 5282 CmdArgs.push_back("-Bdynamic"); 5283 if (Args.hasArg(options::OPT_shared)) { 5284 CmdArgs.push_back("-shared"); 5285 } else { 5286 CmdArgs.push_back("-dynamic-linker"); 5287 CmdArgs.push_back("/usr/libexec/ld.so"); 5288 } 5289 } 5290 5291 if (Output.isFilename()) { 5292 CmdArgs.push_back("-o"); 5293 CmdArgs.push_back(Output.getFilename()); 5294 } else { 5295 assert(Output.isNothing() && "Invalid output."); 5296 } 5297 5298 if (!Args.hasArg(options::OPT_nostdlib) && 5299 !Args.hasArg(options::OPT_nostartfiles)) { 5300 if (!Args.hasArg(options::OPT_shared)) { 5301 if (Args.hasArg(options::OPT_pg)) 5302 CmdArgs.push_back(Args.MakeArgString( 5303 getToolChain().GetFilePath("gcrt0.o"))); 5304 else 5305 CmdArgs.push_back(Args.MakeArgString( 5306 getToolChain().GetFilePath("crt0.o"))); 5307 CmdArgs.push_back(Args.MakeArgString( 5308 getToolChain().GetFilePath("crtbegin.o"))); 5309 } else { 5310 CmdArgs.push_back(Args.MakeArgString( 5311 getToolChain().GetFilePath("crtbeginS.o"))); 5312 } 5313 } 5314 5315 Args.AddAllArgs(CmdArgs, options::OPT_L); 5316 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5317 Args.AddAllArgs(CmdArgs, options::OPT_e); 5318 5319 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5320 5321 if (!Args.hasArg(options::OPT_nostdlib) && 5322 !Args.hasArg(options::OPT_nodefaultlibs)) { 5323 if (D.CCCIsCXX) { 5324 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5325 if (Args.hasArg(options::OPT_pg)) 5326 CmdArgs.push_back("-lm_p"); 5327 else 5328 CmdArgs.push_back("-lm"); 5329 } 5330 5331 if (Args.hasArg(options::OPT_pthread)) { 5332 if (!Args.hasArg(options::OPT_shared) && 5333 Args.hasArg(options::OPT_pg)) 5334 CmdArgs.push_back("-lpthread_p"); 5335 else 5336 CmdArgs.push_back("-lpthread"); 5337 } 5338 5339 if (!Args.hasArg(options::OPT_shared)) { 5340 if (Args.hasArg(options::OPT_pg)) 5341 CmdArgs.push_back("-lc_p"); 5342 else 5343 CmdArgs.push_back("-lc"); 5344 } 5345 5346 std::string myarch = "-lclang_rt."; 5347 const llvm::Triple &T = getToolChain().getTriple(); 5348 llvm::Triple::ArchType Arch = T.getArch(); 5349 switch (Arch) { 5350 case llvm::Triple::arm: 5351 myarch += ("arm"); 5352 break; 5353 case llvm::Triple::x86: 5354 myarch += ("i386"); 5355 break; 5356 case llvm::Triple::x86_64: 5357 myarch += ("amd64"); 5358 break; 5359 default: 5360 assert(0 && "Unsupported architecture"); 5361 } 5362 CmdArgs.push_back(Args.MakeArgString(myarch)); 5363 } 5364 5365 if (!Args.hasArg(options::OPT_nostdlib) && 5366 !Args.hasArg(options::OPT_nostartfiles)) { 5367 if (!Args.hasArg(options::OPT_shared)) 5368 CmdArgs.push_back(Args.MakeArgString( 5369 getToolChain().GetFilePath("crtend.o"))); 5370 else 5371 CmdArgs.push_back(Args.MakeArgString( 5372 getToolChain().GetFilePath("crtendS.o"))); 5373 } 5374 5375 const char *Exec = 5376 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5377 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5378} 5379 5380void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5381 const InputInfo &Output, 5382 const InputInfoList &Inputs, 5383 const ArgList &Args, 5384 const char *LinkingOutput) const { 5385 ArgStringList CmdArgs; 5386 5387 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 5388 // instruct as in the base system to assemble 32-bit code. 5389 if (getToolChain().getArch() == llvm::Triple::x86) 5390 CmdArgs.push_back("--32"); 5391 else if (getToolChain().getArch() == llvm::Triple::ppc) 5392 CmdArgs.push_back("-a32"); 5393 else if (getToolChain().getArch() == llvm::Triple::mips || 5394 getToolChain().getArch() == llvm::Triple::mipsel || 5395 getToolChain().getArch() == llvm::Triple::mips64 || 5396 getToolChain().getArch() == llvm::Triple::mips64el) { 5397 StringRef CPUName; 5398 StringRef ABIName; 5399 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName); 5400 5401 CmdArgs.push_back("-march"); 5402 CmdArgs.push_back(CPUName.data()); 5403 5404 // Convert ABI name to the GNU tools acceptable variant. 5405 if (ABIName == "o32") 5406 ABIName = "32"; 5407 else if (ABIName == "n64") 5408 ABIName = "64"; 5409 5410 CmdArgs.push_back("-mabi"); 5411 CmdArgs.push_back(ABIName.data()); 5412 5413 if (getToolChain().getArch() == llvm::Triple::mips || 5414 getToolChain().getArch() == llvm::Triple::mips64) 5415 CmdArgs.push_back("-EB"); 5416 else 5417 CmdArgs.push_back("-EL"); 5418 5419 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 5420 options::OPT_fpic, options::OPT_fno_pic, 5421 options::OPT_fPIE, options::OPT_fno_PIE, 5422 options::OPT_fpie, options::OPT_fno_pie); 5423 if (LastPICArg && 5424 (LastPICArg->getOption().matches(options::OPT_fPIC) || 5425 LastPICArg->getOption().matches(options::OPT_fpic) || 5426 LastPICArg->getOption().matches(options::OPT_fPIE) || 5427 LastPICArg->getOption().matches(options::OPT_fpie))) { 5428 CmdArgs.push_back("-KPIC"); 5429 } 5430 } else if (getToolChain().getArch() == llvm::Triple::arm || 5431 getToolChain().getArch() == llvm::Triple::thumb) { 5432 CmdArgs.push_back("-mfpu=softvfp"); 5433 switch(getToolChain().getTriple().getEnvironment()) { 5434 case llvm::Triple::GNUEABI: 5435 case llvm::Triple::EABI: 5436 break; 5437 5438 default: 5439 CmdArgs.push_back("-matpcs"); 5440 } 5441 } 5442 5443 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5444 options::OPT_Xassembler); 5445 5446 CmdArgs.push_back("-o"); 5447 CmdArgs.push_back(Output.getFilename()); 5448 5449 for (InputInfoList::const_iterator 5450 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5451 const InputInfo &II = *it; 5452 CmdArgs.push_back(II.getFilename()); 5453 } 5454 5455 const char *Exec = 5456 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5457 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5458} 5459 5460void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 5461 const InputInfo &Output, 5462 const InputInfoList &Inputs, 5463 const ArgList &Args, 5464 const char *LinkingOutput) const { 5465 const toolchains::FreeBSD& ToolChain = 5466 static_cast<const toolchains::FreeBSD&>(getToolChain()); 5467 const Driver &D = ToolChain.getDriver(); 5468 ArgStringList CmdArgs; 5469 5470 // Silence warning for "clang -g foo.o -o foo" 5471 Args.ClaimAllArgs(options::OPT_g_Group); 5472 // and "clang -emit-llvm foo.o -o foo" 5473 Args.ClaimAllArgs(options::OPT_emit_llvm); 5474 // and for "clang -w foo.o -o foo". Other warning options are already 5475 // handled somewhere else. 5476 Args.ClaimAllArgs(options::OPT_w); 5477 5478 if (!D.SysRoot.empty()) 5479 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 5480 5481 if (Args.hasArg(options::OPT_pie)) 5482 CmdArgs.push_back("-pie"); 5483 5484 if (Args.hasArg(options::OPT_static)) { 5485 CmdArgs.push_back("-Bstatic"); 5486 } else { 5487 if (Args.hasArg(options::OPT_rdynamic)) 5488 CmdArgs.push_back("-export-dynamic"); 5489 CmdArgs.push_back("--eh-frame-hdr"); 5490 if (Args.hasArg(options::OPT_shared)) { 5491 CmdArgs.push_back("-Bshareable"); 5492 } else { 5493 CmdArgs.push_back("-dynamic-linker"); 5494 CmdArgs.push_back("/libexec/ld-elf.so.1"); 5495 } 5496 if (ToolChain.getTriple().getOSMajorVersion() >= 9) { 5497 llvm::Triple::ArchType Arch = ToolChain.getArch(); 5498 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc || 5499 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) { 5500 CmdArgs.push_back("--hash-style=both"); 5501 } 5502 } 5503 CmdArgs.push_back("--enable-new-dtags"); 5504 } 5505 5506 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 5507 // instruct ld in the base system to link 32-bit code. 5508 if (ToolChain.getArch() == llvm::Triple::x86) { 5509 CmdArgs.push_back("-m"); 5510 CmdArgs.push_back("elf_i386_fbsd"); 5511 } 5512 5513 if (ToolChain.getArch() == llvm::Triple::ppc) { 5514 CmdArgs.push_back("-m"); 5515 CmdArgs.push_back("elf32ppc_fbsd"); 5516 } 5517 5518 if (Output.isFilename()) { 5519 CmdArgs.push_back("-o"); 5520 CmdArgs.push_back(Output.getFilename()); 5521 } else { 5522 assert(Output.isNothing() && "Invalid output."); 5523 } 5524 5525 if (!Args.hasArg(options::OPT_nostdlib) && 5526 !Args.hasArg(options::OPT_nostartfiles)) { 5527 const char *crt1 = NULL; 5528 if (!Args.hasArg(options::OPT_shared)) { 5529 if (Args.hasArg(options::OPT_pg)) 5530 crt1 = "gcrt1.o"; 5531 else if (Args.hasArg(options::OPT_pie)) 5532 crt1 = "Scrt1.o"; 5533 else 5534 crt1 = "crt1.o"; 5535 } 5536 if (crt1) 5537 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 5538 5539 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 5540 5541 const char *crtbegin = NULL; 5542 if (Args.hasArg(options::OPT_static)) 5543 crtbegin = "crtbeginT.o"; 5544 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 5545 crtbegin = "crtbeginS.o"; 5546 else 5547 crtbegin = "crtbegin.o"; 5548 5549 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 5550 } 5551 5552 Args.AddAllArgs(CmdArgs, options::OPT_L); 5553 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 5554 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 5555 i != e; ++i) 5556 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 5557 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5558 Args.AddAllArgs(CmdArgs, options::OPT_e); 5559 Args.AddAllArgs(CmdArgs, options::OPT_s); 5560 Args.AddAllArgs(CmdArgs, options::OPT_t); 5561 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 5562 Args.AddAllArgs(CmdArgs, options::OPT_r); 5563 5564 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 5565 5566 if (!Args.hasArg(options::OPT_nostdlib) && 5567 !Args.hasArg(options::OPT_nodefaultlibs)) { 5568 if (D.CCCIsCXX) { 5569 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 5570 if (Args.hasArg(options::OPT_pg)) 5571 CmdArgs.push_back("-lm_p"); 5572 else 5573 CmdArgs.push_back("-lm"); 5574 } 5575 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 5576 // the default system libraries. Just mimic this for now. 5577 if (Args.hasArg(options::OPT_pg)) 5578 CmdArgs.push_back("-lgcc_p"); 5579 else 5580 CmdArgs.push_back("-lgcc"); 5581 if (Args.hasArg(options::OPT_static)) { 5582 CmdArgs.push_back("-lgcc_eh"); 5583 } else if (Args.hasArg(options::OPT_pg)) { 5584 CmdArgs.push_back("-lgcc_eh_p"); 5585 } else { 5586 CmdArgs.push_back("--as-needed"); 5587 CmdArgs.push_back("-lgcc_s"); 5588 CmdArgs.push_back("--no-as-needed"); 5589 } 5590 5591 if (Args.hasArg(options::OPT_pthread)) { 5592 if (Args.hasArg(options::OPT_pg)) 5593 CmdArgs.push_back("-lpthread_p"); 5594 else 5595 CmdArgs.push_back("-lpthread"); 5596 } 5597 5598 if (Args.hasArg(options::OPT_pg)) { 5599 if (Args.hasArg(options::OPT_shared)) 5600 CmdArgs.push_back("-lc"); 5601 else 5602 CmdArgs.push_back("-lc_p"); 5603 CmdArgs.push_back("-lgcc_p"); 5604 } else { 5605 CmdArgs.push_back("-lc"); 5606 CmdArgs.push_back("-lgcc"); 5607 } 5608 5609 if (Args.hasArg(options::OPT_static)) { 5610 CmdArgs.push_back("-lgcc_eh"); 5611 } else if (Args.hasArg(options::OPT_pg)) { 5612 CmdArgs.push_back("-lgcc_eh_p"); 5613 } else { 5614 CmdArgs.push_back("--as-needed"); 5615 CmdArgs.push_back("-lgcc_s"); 5616 CmdArgs.push_back("--no-as-needed"); 5617 } 5618 } 5619 5620 if (!Args.hasArg(options::OPT_nostdlib) && 5621 !Args.hasArg(options::OPT_nostartfiles)) { 5622 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 5623 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o"))); 5624 else 5625 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o"))); 5626 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 5627 } 5628 5629 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple()); 5630 5631 const char *Exec = 5632 Args.MakeArgString(ToolChain.GetProgramPath("ld")); 5633 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5634} 5635 5636void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5637 const InputInfo &Output, 5638 const InputInfoList &Inputs, 5639 const ArgList &Args, 5640 const char *LinkingOutput) const { 5641 ArgStringList CmdArgs; 5642 5643 // When building 32-bit code on NetBSD/amd64, we have to explicitly 5644 // instruct as in the base system to assemble 32-bit code. 5645 if (getToolChain().getArch() == llvm::Triple::x86) 5646 CmdArgs.push_back("--32"); 5647 5648 // Set byte order explicitly 5649 if (getToolChain().getArch() == llvm::Triple::mips) 5650 CmdArgs.push_back("-EB"); 5651 else if (getToolChain().getArch() == llvm::Triple::mipsel) 5652 CmdArgs.push_back("-EL"); 5653 5654 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5655 options::OPT_Xassembler); 5656 5657 CmdArgs.push_back("-o"); 5658 CmdArgs.push_back(Output.getFilename()); 5659 5660 for (InputInfoList::const_iterator 5661 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5662 const InputInfo &II = *it; 5663 CmdArgs.push_back(II.getFilename()); 5664 } 5665 5666 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as"))); 5667 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5668} 5669 5670void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 5671 const InputInfo &Output, 5672 const InputInfoList &Inputs, 5673 const ArgList &Args, 5674 const char *LinkingOutput) const { 5675 const Driver &D = getToolChain().getDriver(); 5676 ArgStringList CmdArgs; 5677 5678 if (!D.SysRoot.empty()) 5679 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 5680 5681 if (Args.hasArg(options::OPT_static)) { 5682 CmdArgs.push_back("-Bstatic"); 5683 } else { 5684 if (Args.hasArg(options::OPT_rdynamic)) 5685 CmdArgs.push_back("-export-dynamic"); 5686 CmdArgs.push_back("--eh-frame-hdr"); 5687 if (Args.hasArg(options::OPT_shared)) { 5688 CmdArgs.push_back("-Bshareable"); 5689 } else { 5690 CmdArgs.push_back("-dynamic-linker"); 5691 CmdArgs.push_back("/libexec/ld.elf_so"); 5692 } 5693 } 5694 5695 // When building 32-bit code on NetBSD/amd64, we have to explicitly 5696 // instruct ld in the base system to link 32-bit code. 5697 if (getToolChain().getArch() == llvm::Triple::x86) { 5698 CmdArgs.push_back("-m"); 5699 CmdArgs.push_back("elf_i386"); 5700 } 5701 5702 if (Output.isFilename()) { 5703 CmdArgs.push_back("-o"); 5704 CmdArgs.push_back(Output.getFilename()); 5705 } else { 5706 assert(Output.isNothing() && "Invalid output."); 5707 } 5708 5709 if (!Args.hasArg(options::OPT_nostdlib) && 5710 !Args.hasArg(options::OPT_nostartfiles)) { 5711 if (!Args.hasArg(options::OPT_shared)) { 5712 CmdArgs.push_back(Args.MakeArgString( 5713 getToolChain().GetFilePath("crt0.o"))); 5714 CmdArgs.push_back(Args.MakeArgString( 5715 getToolChain().GetFilePath("crti.o"))); 5716 CmdArgs.push_back(Args.MakeArgString( 5717 getToolChain().GetFilePath("crtbegin.o"))); 5718 } else { 5719 CmdArgs.push_back(Args.MakeArgString( 5720 getToolChain().GetFilePath("crti.o"))); 5721 CmdArgs.push_back(Args.MakeArgString( 5722 getToolChain().GetFilePath("crtbeginS.o"))); 5723 } 5724 } 5725 5726 Args.AddAllArgs(CmdArgs, options::OPT_L); 5727 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5728 Args.AddAllArgs(CmdArgs, options::OPT_e); 5729 Args.AddAllArgs(CmdArgs, options::OPT_s); 5730 Args.AddAllArgs(CmdArgs, options::OPT_t); 5731 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 5732 Args.AddAllArgs(CmdArgs, options::OPT_r); 5733 5734 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5735 5736 if (!Args.hasArg(options::OPT_nostdlib) && 5737 !Args.hasArg(options::OPT_nodefaultlibs)) { 5738 if (D.CCCIsCXX) { 5739 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5740 CmdArgs.push_back("-lm"); 5741 } 5742 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 5743 // the default system libraries. Just mimic this for now. 5744 if (Args.hasArg(options::OPT_static)) { 5745 CmdArgs.push_back("-lgcc_eh"); 5746 } else { 5747 CmdArgs.push_back("--as-needed"); 5748 CmdArgs.push_back("-lgcc_s"); 5749 CmdArgs.push_back("--no-as-needed"); 5750 } 5751 CmdArgs.push_back("-lgcc"); 5752 5753 if (Args.hasArg(options::OPT_pthread)) 5754 CmdArgs.push_back("-lpthread"); 5755 CmdArgs.push_back("-lc"); 5756 5757 CmdArgs.push_back("-lgcc"); 5758 if (Args.hasArg(options::OPT_static)) { 5759 CmdArgs.push_back("-lgcc_eh"); 5760 } else { 5761 CmdArgs.push_back("--as-needed"); 5762 CmdArgs.push_back("-lgcc_s"); 5763 CmdArgs.push_back("--no-as-needed"); 5764 } 5765 } 5766 5767 if (!Args.hasArg(options::OPT_nostdlib) && 5768 !Args.hasArg(options::OPT_nostartfiles)) { 5769 if (!Args.hasArg(options::OPT_shared)) 5770 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 5771 "crtend.o"))); 5772 else 5773 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 5774 "crtendS.o"))); 5775 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 5776 "crtn.o"))); 5777 } 5778 5779 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 5780 5781 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5782 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5783} 5784 5785void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5786 const InputInfo &Output, 5787 const InputInfoList &Inputs, 5788 const ArgList &Args, 5789 const char *LinkingOutput) const { 5790 ArgStringList CmdArgs; 5791 5792 // Add --32/--64 to make sure we get the format we want. 5793 // This is incomplete 5794 if (getToolChain().getArch() == llvm::Triple::x86) { 5795 CmdArgs.push_back("--32"); 5796 } else if (getToolChain().getArch() == llvm::Triple::x86_64) { 5797 CmdArgs.push_back("--64"); 5798 } else if (getToolChain().getArch() == llvm::Triple::ppc) { 5799 CmdArgs.push_back("-a32"); 5800 CmdArgs.push_back("-mppc"); 5801 CmdArgs.push_back("-many"); 5802 } else if (getToolChain().getArch() == llvm::Triple::ppc64) { 5803 CmdArgs.push_back("-a64"); 5804 CmdArgs.push_back("-mppc64"); 5805 CmdArgs.push_back("-many"); 5806 } else if (getToolChain().getArch() == llvm::Triple::arm) { 5807 StringRef MArch = getToolChain().getArchName(); 5808 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 5809 CmdArgs.push_back("-mfpu=neon"); 5810 5811 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args, 5812 getToolChain().getTriple()); 5813 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI)); 5814 5815 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 5816 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 5817 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); 5818 } else if (getToolChain().getArch() == llvm::Triple::mips || 5819 getToolChain().getArch() == llvm::Triple::mipsel || 5820 getToolChain().getArch() == llvm::Triple::mips64 || 5821 getToolChain().getArch() == llvm::Triple::mips64el) { 5822 StringRef CPUName; 5823 StringRef ABIName; 5824 getMipsCPUAndABI(Args, getToolChain(), CPUName, ABIName); 5825 5826 CmdArgs.push_back("-march"); 5827 CmdArgs.push_back(CPUName.data()); 5828 5829 // Convert ABI name to the GNU tools acceptable variant. 5830 if (ABIName == "o32") 5831 ABIName = "32"; 5832 else if (ABIName == "n64") 5833 ABIName = "64"; 5834 5835 CmdArgs.push_back("-mabi"); 5836 CmdArgs.push_back(ABIName.data()); 5837 5838 if (getToolChain().getArch() == llvm::Triple::mips || 5839 getToolChain().getArch() == llvm::Triple::mips64) 5840 CmdArgs.push_back("-EB"); 5841 else 5842 CmdArgs.push_back("-EL"); 5843 5844 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 5845 options::OPT_fpic, options::OPT_fno_pic, 5846 options::OPT_fPIE, options::OPT_fno_PIE, 5847 options::OPT_fpie, options::OPT_fno_pie); 5848 if (LastPICArg && 5849 (LastPICArg->getOption().matches(options::OPT_fPIC) || 5850 LastPICArg->getOption().matches(options::OPT_fpic) || 5851 LastPICArg->getOption().matches(options::OPT_fPIE) || 5852 LastPICArg->getOption().matches(options::OPT_fpie))) { 5853 CmdArgs.push_back("-KPIC"); 5854 } 5855 } 5856 5857 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5858 options::OPT_Xassembler); 5859 5860 CmdArgs.push_back("-o"); 5861 CmdArgs.push_back(Output.getFilename()); 5862 5863 for (InputInfoList::const_iterator 5864 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5865 const InputInfo &II = *it; 5866 CmdArgs.push_back(II.getFilename()); 5867 } 5868 5869 const char *Exec = 5870 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5871 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5872} 5873 5874static void AddLibgcc(llvm::Triple Triple, const Driver &D, 5875 ArgStringList &CmdArgs, const ArgList &Args) { 5876 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android; 5877 bool StaticLibgcc = isAndroid || Args.hasArg(options::OPT_static) || 5878 Args.hasArg(options::OPT_static_libgcc); 5879 if (!D.CCCIsCXX) 5880 CmdArgs.push_back("-lgcc"); 5881 5882 if (StaticLibgcc) { 5883 if (D.CCCIsCXX) 5884 CmdArgs.push_back("-lgcc"); 5885 } else { 5886 if (!D.CCCIsCXX) 5887 CmdArgs.push_back("--as-needed"); 5888 CmdArgs.push_back("-lgcc_s"); 5889 if (!D.CCCIsCXX) 5890 CmdArgs.push_back("--no-as-needed"); 5891 } 5892 5893 if (StaticLibgcc && !isAndroid) 5894 CmdArgs.push_back("-lgcc_eh"); 5895 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX) 5896 CmdArgs.push_back("-lgcc"); 5897} 5898 5899static bool hasMipsN32ABIArg(const ArgList &Args) { 5900 Arg *A = Args.getLastArg(options::OPT_mabi_EQ); 5901 return A && (A->getValue() == StringRef("n32")); 5902} 5903 5904void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA, 5905 const InputInfo &Output, 5906 const InputInfoList &Inputs, 5907 const ArgList &Args, 5908 const char *LinkingOutput) const { 5909 const toolchains::Linux& ToolChain = 5910 static_cast<const toolchains::Linux&>(getToolChain()); 5911 const Driver &D = ToolChain.getDriver(); 5912 const bool isAndroid = 5913 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android; 5914 5915 ArgStringList CmdArgs; 5916 5917 // Silence warning for "clang -g foo.o -o foo" 5918 Args.ClaimAllArgs(options::OPT_g_Group); 5919 // and "clang -emit-llvm foo.o -o foo" 5920 Args.ClaimAllArgs(options::OPT_emit_llvm); 5921 // and for "clang -w foo.o -o foo". Other warning options are already 5922 // handled somewhere else. 5923 Args.ClaimAllArgs(options::OPT_w); 5924 5925 if (!D.SysRoot.empty()) 5926 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 5927 5928 if (Args.hasArg(options::OPT_pie)) 5929 CmdArgs.push_back("-pie"); 5930 5931 if (Args.hasArg(options::OPT_rdynamic)) 5932 CmdArgs.push_back("-export-dynamic"); 5933 5934 if (Args.hasArg(options::OPT_s)) 5935 CmdArgs.push_back("-s"); 5936 5937 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(), 5938 e = ToolChain.ExtraOpts.end(); 5939 i != e; ++i) 5940 CmdArgs.push_back(i->c_str()); 5941 5942 if (!Args.hasArg(options::OPT_static)) { 5943 CmdArgs.push_back("--eh-frame-hdr"); 5944 } 5945 5946 CmdArgs.push_back("-m"); 5947 if (ToolChain.getArch() == llvm::Triple::x86) 5948 CmdArgs.push_back("elf_i386"); 5949 else if (ToolChain.getArch() == llvm::Triple::arm 5950 || ToolChain.getArch() == llvm::Triple::thumb) 5951 CmdArgs.push_back("armelf_linux_eabi"); 5952 else if (ToolChain.getArch() == llvm::Triple::ppc) 5953 CmdArgs.push_back("elf32ppclinux"); 5954 else if (ToolChain.getArch() == llvm::Triple::ppc64) 5955 CmdArgs.push_back("elf64ppc"); 5956 else if (ToolChain.getArch() == llvm::Triple::mips) 5957 CmdArgs.push_back("elf32btsmip"); 5958 else if (ToolChain.getArch() == llvm::Triple::mipsel) 5959 CmdArgs.push_back("elf32ltsmip"); 5960 else if (ToolChain.getArch() == llvm::Triple::mips64) { 5961 if (hasMipsN32ABIArg(Args)) 5962 CmdArgs.push_back("elf32btsmipn32"); 5963 else 5964 CmdArgs.push_back("elf64btsmip"); 5965 } 5966 else if (ToolChain.getArch() == llvm::Triple::mips64el) { 5967 if (hasMipsN32ABIArg(Args)) 5968 CmdArgs.push_back("elf32ltsmipn32"); 5969 else 5970 CmdArgs.push_back("elf64ltsmip"); 5971 } 5972 else 5973 CmdArgs.push_back("elf_x86_64"); 5974 5975 if (Args.hasArg(options::OPT_static)) { 5976 if (ToolChain.getArch() == llvm::Triple::arm 5977 || ToolChain.getArch() == llvm::Triple::thumb) 5978 CmdArgs.push_back("-Bstatic"); 5979 else 5980 CmdArgs.push_back("-static"); 5981 } else if (Args.hasArg(options::OPT_shared)) { 5982 CmdArgs.push_back("-shared"); 5983 if (isAndroid) { 5984 CmdArgs.push_back("-Bsymbolic"); 5985 } 5986 } 5987 5988 if (ToolChain.getArch() == llvm::Triple::arm || 5989 ToolChain.getArch() == llvm::Triple::thumb || 5990 (!Args.hasArg(options::OPT_static) && 5991 !Args.hasArg(options::OPT_shared))) { 5992 CmdArgs.push_back("-dynamic-linker"); 5993 if (isAndroid) 5994 CmdArgs.push_back("/system/bin/linker"); 5995 else if (ToolChain.getArch() == llvm::Triple::x86) 5996 CmdArgs.push_back("/lib/ld-linux.so.2"); 5997 else if (ToolChain.getArch() == llvm::Triple::arm || 5998 ToolChain.getArch() == llvm::Triple::thumb) { 5999 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF) 6000 CmdArgs.push_back("/lib/ld-linux-armhf.so.3"); 6001 else 6002 CmdArgs.push_back("/lib/ld-linux.so.3"); 6003 } 6004 else if (ToolChain.getArch() == llvm::Triple::mips || 6005 ToolChain.getArch() == llvm::Triple::mipsel) 6006 CmdArgs.push_back("/lib/ld.so.1"); 6007 else if (ToolChain.getArch() == llvm::Triple::mips64 || 6008 ToolChain.getArch() == llvm::Triple::mips64el) { 6009 if (hasMipsN32ABIArg(Args)) 6010 CmdArgs.push_back("/lib32/ld.so.1"); 6011 else 6012 CmdArgs.push_back("/lib64/ld.so.1"); 6013 } 6014 else if (ToolChain.getArch() == llvm::Triple::ppc) 6015 CmdArgs.push_back("/lib/ld.so.1"); 6016 else if (ToolChain.getArch() == llvm::Triple::ppc64) 6017 CmdArgs.push_back("/lib64/ld64.so.1"); 6018 else 6019 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2"); 6020 } 6021 6022 CmdArgs.push_back("-o"); 6023 CmdArgs.push_back(Output.getFilename()); 6024 6025 if (!Args.hasArg(options::OPT_nostdlib) && 6026 !Args.hasArg(options::OPT_nostartfiles)) { 6027 if (!isAndroid) { 6028 const char *crt1 = NULL; 6029 if (!Args.hasArg(options::OPT_shared)){ 6030 if (Args.hasArg(options::OPT_pie)) 6031 crt1 = "Scrt1.o"; 6032 else 6033 crt1 = "crt1.o"; 6034 } 6035 if (crt1) 6036 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 6037 6038 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 6039 } 6040 6041 const char *crtbegin; 6042 if (Args.hasArg(options::OPT_static)) 6043 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o"; 6044 else if (Args.hasArg(options::OPT_shared)) 6045 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o"; 6046 else if (Args.hasArg(options::OPT_pie)) 6047 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o"; 6048 else 6049 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o"; 6050 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 6051 6052 // Add crtfastmath.o if available and fast math is enabled. 6053 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs); 6054 } 6055 6056 Args.AddAllArgs(CmdArgs, options::OPT_L); 6057 6058 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 6059 6060 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 6061 i != e; ++i) 6062 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 6063 6064 // Tell the linker to load the plugin. This has to come before AddLinkerInputs 6065 // as gold requires -plugin to come before any -plugin-opt that -Wl might 6066 // forward. 6067 if (D.IsUsingLTO(Args) || Args.hasArg(options::OPT_use_gold_plugin)) { 6068 CmdArgs.push_back("-plugin"); 6069 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so"; 6070 CmdArgs.push_back(Args.MakeArgString(Plugin)); 6071 } 6072 6073 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 6074 CmdArgs.push_back("--no-demangle"); 6075 6076 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 6077 6078 SanitizerArgs Sanitize(D, Args); 6079 6080 // Call this before we add the C++ ABI library. 6081 if (Sanitize.needsUbsanRt()) 6082 addUbsanRTLinux(getToolChain(), Args, CmdArgs); 6083 6084 if (D.CCCIsCXX && 6085 !Args.hasArg(options::OPT_nostdlib) && 6086 !Args.hasArg(options::OPT_nodefaultlibs)) { 6087 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 6088 !Args.hasArg(options::OPT_static); 6089 if (OnlyLibstdcxxStatic) 6090 CmdArgs.push_back("-Bstatic"); 6091 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 6092 if (OnlyLibstdcxxStatic) 6093 CmdArgs.push_back("-Bdynamic"); 6094 CmdArgs.push_back("-lm"); 6095 } 6096 6097 // Call this before we add the C run-time. 6098 if (Sanitize.needsAsanRt()) 6099 addAsanRTLinux(getToolChain(), Args, CmdArgs); 6100 if (Sanitize.needsTsanRt()) 6101 addTsanRTLinux(getToolChain(), Args, CmdArgs); 6102 6103 if (!Args.hasArg(options::OPT_nostdlib)) { 6104 if (!Args.hasArg(options::OPT_nodefaultlibs)) { 6105 if (Args.hasArg(options::OPT_static)) 6106 CmdArgs.push_back("--start-group"); 6107 6108 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args); 6109 6110 if (Args.hasArg(options::OPT_pthread) || 6111 Args.hasArg(options::OPT_pthreads)) 6112 CmdArgs.push_back("-lpthread"); 6113 6114 CmdArgs.push_back("-lc"); 6115 6116 if (Args.hasArg(options::OPT_static)) 6117 CmdArgs.push_back("--end-group"); 6118 else 6119 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args); 6120 } 6121 6122 if (!Args.hasArg(options::OPT_nostartfiles)) { 6123 const char *crtend; 6124 if (Args.hasArg(options::OPT_shared)) 6125 crtend = isAndroid ? "crtend_so.o" : "crtendS.o"; 6126 else if (Args.hasArg(options::OPT_pie)) 6127 crtend = isAndroid ? "crtend_android.o" : "crtendS.o"; 6128 else 6129 crtend = isAndroid ? "crtend_android.o" : "crtend.o"; 6130 6131 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 6132 if (!isAndroid) 6133 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 6134 } 6135 } 6136 6137 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6138 6139 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); 6140} 6141 6142void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6143 const InputInfo &Output, 6144 const InputInfoList &Inputs, 6145 const ArgList &Args, 6146 const char *LinkingOutput) const { 6147 ArgStringList CmdArgs; 6148 6149 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6150 options::OPT_Xassembler); 6151 6152 CmdArgs.push_back("-o"); 6153 CmdArgs.push_back(Output.getFilename()); 6154 6155 for (InputInfoList::const_iterator 6156 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6157 const InputInfo &II = *it; 6158 CmdArgs.push_back(II.getFilename()); 6159 } 6160 6161 const char *Exec = 6162 Args.MakeArgString(getToolChain().GetProgramPath("as")); 6163 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6164} 6165 6166void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, 6167 const InputInfo &Output, 6168 const InputInfoList &Inputs, 6169 const ArgList &Args, 6170 const char *LinkingOutput) const { 6171 const Driver &D = getToolChain().getDriver(); 6172 ArgStringList CmdArgs; 6173 6174 if (Output.isFilename()) { 6175 CmdArgs.push_back("-o"); 6176 CmdArgs.push_back(Output.getFilename()); 6177 } else { 6178 assert(Output.isNothing() && "Invalid output."); 6179 } 6180 6181 if (!Args.hasArg(options::OPT_nostdlib) && 6182 !Args.hasArg(options::OPT_nostartfiles)) { 6183 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); 6184 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 6185 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); 6186 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); 6187 } 6188 6189 Args.AddAllArgs(CmdArgs, options::OPT_L); 6190 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 6191 Args.AddAllArgs(CmdArgs, options::OPT_e); 6192 6193 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 6194 6195 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6196 6197 if (!Args.hasArg(options::OPT_nostdlib) && 6198 !Args.hasArg(options::OPT_nodefaultlibs)) { 6199 if (D.CCCIsCXX) { 6200 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 6201 CmdArgs.push_back("-lm"); 6202 } 6203 } 6204 6205 if (!Args.hasArg(options::OPT_nostdlib) && 6206 !Args.hasArg(options::OPT_nostartfiles)) { 6207 if (Args.hasArg(options::OPT_pthread)) 6208 CmdArgs.push_back("-lpthread"); 6209 CmdArgs.push_back("-lc"); 6210 CmdArgs.push_back("-lCompilerRT-Generic"); 6211 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib"); 6212 CmdArgs.push_back( 6213 Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); 6214 } 6215 6216 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld")); 6217 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6218} 6219 6220/// DragonFly Tools 6221 6222// For now, DragonFly Assemble does just about the same as for 6223// FreeBSD, but this may change soon. 6224void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6225 const InputInfo &Output, 6226 const InputInfoList &Inputs, 6227 const ArgList &Args, 6228 const char *LinkingOutput) const { 6229 ArgStringList CmdArgs; 6230 6231 // When building 32-bit code on DragonFly/pc64, we have to explicitly 6232 // instruct as in the base system to assemble 32-bit code. 6233 if (getToolChain().getArch() == llvm::Triple::x86) 6234 CmdArgs.push_back("--32"); 6235 6236 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6237 options::OPT_Xassembler); 6238 6239 CmdArgs.push_back("-o"); 6240 CmdArgs.push_back(Output.getFilename()); 6241 6242 for (InputInfoList::const_iterator 6243 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6244 const InputInfo &II = *it; 6245 CmdArgs.push_back(II.getFilename()); 6246 } 6247 6248 const char *Exec = 6249 Args.MakeArgString(getToolChain().GetProgramPath("as")); 6250 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6251} 6252 6253void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 6254 const InputInfo &Output, 6255 const InputInfoList &Inputs, 6256 const ArgList &Args, 6257 const char *LinkingOutput) const { 6258 const Driver &D = getToolChain().getDriver(); 6259 ArgStringList CmdArgs; 6260 6261 if (!D.SysRoot.empty()) 6262 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 6263 6264 if (Args.hasArg(options::OPT_static)) { 6265 CmdArgs.push_back("-Bstatic"); 6266 } else { 6267 if (Args.hasArg(options::OPT_shared)) 6268 CmdArgs.push_back("-Bshareable"); 6269 else { 6270 CmdArgs.push_back("-dynamic-linker"); 6271 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 6272 } 6273 } 6274 6275 // When building 32-bit code on DragonFly/pc64, we have to explicitly 6276 // instruct ld in the base system to link 32-bit code. 6277 if (getToolChain().getArch() == llvm::Triple::x86) { 6278 CmdArgs.push_back("-m"); 6279 CmdArgs.push_back("elf_i386"); 6280 } 6281 6282 if (Output.isFilename()) { 6283 CmdArgs.push_back("-o"); 6284 CmdArgs.push_back(Output.getFilename()); 6285 } else { 6286 assert(Output.isNothing() && "Invalid output."); 6287 } 6288 6289 if (!Args.hasArg(options::OPT_nostdlib) && 6290 !Args.hasArg(options::OPT_nostartfiles)) { 6291 if (!Args.hasArg(options::OPT_shared)) { 6292 CmdArgs.push_back( 6293 Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); 6294 CmdArgs.push_back( 6295 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 6296 CmdArgs.push_back( 6297 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); 6298 } else { 6299 CmdArgs.push_back( 6300 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 6301 CmdArgs.push_back( 6302 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); 6303 } 6304 } 6305 6306 Args.AddAllArgs(CmdArgs, options::OPT_L); 6307 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 6308 Args.AddAllArgs(CmdArgs, options::OPT_e); 6309 6310 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 6311 6312 if (!Args.hasArg(options::OPT_nostdlib) && 6313 !Args.hasArg(options::OPT_nodefaultlibs)) { 6314 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 6315 // rpaths 6316 CmdArgs.push_back("-L/usr/lib/gcc41"); 6317 6318 if (!Args.hasArg(options::OPT_static)) { 6319 CmdArgs.push_back("-rpath"); 6320 CmdArgs.push_back("/usr/lib/gcc41"); 6321 6322 CmdArgs.push_back("-rpath-link"); 6323 CmdArgs.push_back("/usr/lib/gcc41"); 6324 6325 CmdArgs.push_back("-rpath"); 6326 CmdArgs.push_back("/usr/lib"); 6327 6328 CmdArgs.push_back("-rpath-link"); 6329 CmdArgs.push_back("/usr/lib"); 6330 } 6331 6332 if (D.CCCIsCXX) { 6333 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 6334 CmdArgs.push_back("-lm"); 6335 } 6336 6337 if (Args.hasArg(options::OPT_shared)) { 6338 CmdArgs.push_back("-lgcc_pic"); 6339 } else { 6340 CmdArgs.push_back("-lgcc"); 6341 } 6342 6343 6344 if (Args.hasArg(options::OPT_pthread)) 6345 CmdArgs.push_back("-lpthread"); 6346 6347 if (!Args.hasArg(options::OPT_nolibc)) { 6348 CmdArgs.push_back("-lc"); 6349 } 6350 6351 if (Args.hasArg(options::OPT_shared)) { 6352 CmdArgs.push_back("-lgcc_pic"); 6353 } else { 6354 CmdArgs.push_back("-lgcc"); 6355 } 6356 } 6357 6358 if (!Args.hasArg(options::OPT_nostdlib) && 6359 !Args.hasArg(options::OPT_nostartfiles)) { 6360 if (!Args.hasArg(options::OPT_shared)) 6361 CmdArgs.push_back(Args.MakeArgString( 6362 getToolChain().GetFilePath("crtend.o"))); 6363 else 6364 CmdArgs.push_back(Args.MakeArgString( 6365 getToolChain().GetFilePath("crtendS.o"))); 6366 CmdArgs.push_back(Args.MakeArgString( 6367 getToolChain().GetFilePath("crtn.o"))); 6368 } 6369 6370 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6371 6372 const char *Exec = 6373 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 6374 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6375} 6376 6377void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, 6378 const InputInfo &Output, 6379 const InputInfoList &Inputs, 6380 const ArgList &Args, 6381 const char *LinkingOutput) const { 6382 ArgStringList CmdArgs; 6383 6384 if (Output.isFilename()) { 6385 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") + 6386 Output.getFilename())); 6387 } else { 6388 assert(Output.isNothing() && "Invalid output."); 6389 } 6390 6391 if (!Args.hasArg(options::OPT_nostdlib) && 6392 !Args.hasArg(options::OPT_nostartfiles)) { 6393 CmdArgs.push_back("-defaultlib:libcmt"); 6394 } 6395 6396 CmdArgs.push_back("-nologo"); 6397 6398 Args.AddAllArgValues(CmdArgs, options::OPT_l); 6399 6400 // Add filenames immediately. 6401 for (InputInfoList::const_iterator 6402 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6403 if (it->isFilename()) 6404 CmdArgs.push_back(it->getFilename()); 6405 } 6406 6407 const char *Exec = 6408 Args.MakeArgString(getToolChain().GetProgramPath("link.exe")); 6409 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6410} 6411