2010-09-24 07:48:20 +08:00
|
|
|
//===--- Tools.cpp - Tools Implementations --------------------------------===//
|
2009-03-18 14:00:36 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Tools.h"
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
#include "clang/Driver/Action.h"
|
2009-03-18 15:06:02 +08:00
|
|
|
#include "clang/Driver/Arg.h"
|
2009-03-18 16:07:30 +08:00
|
|
|
#include "clang/Driver/ArgList.h"
|
2009-10-29 10:39:57 +08:00
|
|
|
#include "clang/Driver/Driver.h"
|
|
|
|
#include "clang/Driver/DriverDiagnostic.h"
|
2009-03-18 15:06:02 +08:00
|
|
|
#include "clang/Driver/Compilation.h"
|
|
|
|
#include "clang/Driver/Job.h"
|
2009-03-18 16:07:30 +08:00
|
|
|
#include "clang/Driver/HostInfo.h"
|
2011-07-06 08:26:06 +08:00
|
|
|
#include "clang/Driver/ObjCRuntime.h"
|
2009-03-18 16:07:30 +08:00
|
|
|
#include "clang/Driver/Option.h"
|
2009-11-19 12:25:22 +08:00
|
|
|
#include "clang/Driver/Options.h"
|
2009-03-18 16:07:30 +08:00
|
|
|
#include "clang/Driver/ToolChain.h"
|
2009-03-18 15:06:02 +08:00
|
|
|
#include "clang/Driver/Util.h"
|
|
|
|
|
2009-09-10 06:32:48 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2009-10-29 08:41:01 +08:00
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
2009-09-10 06:32:34 +08:00
|
|
|
#include "llvm/ADT/Twine.h"
|
2011-01-10 10:34:13 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2009-03-27 00:23:12 +08:00
|
|
|
#include "llvm/Support/Format.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-11-30 02:12:39 +08:00
|
|
|
#include "llvm/Support/Host.h"
|
|
|
|
#include "llvm/Support/Process.h"
|
2011-06-16 07:02:42 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-03-18 15:06:02 +08:00
|
|
|
|
|
|
|
#include "InputInfo.h"
|
2009-03-27 00:23:12 +08:00
|
|
|
#include "ToolChains.h"
|
2009-03-18 15:06:02 +08:00
|
|
|
|
2011-04-09 21:31:59 +08:00
|
|
|
#ifdef __CYGWIN__
|
|
|
|
#include <cygwin/version.h>
|
|
|
|
#if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
|
|
|
|
#define IS_CYGWIN15 1
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2009-03-18 14:00:36 +08:00
|
|
|
using namespace clang::driver;
|
|
|
|
using namespace clang::driver::tools;
|
2011-07-23 18:55:15 +08:00
|
|
|
using namespace clang;
|
2009-03-18 14:00:36 +08:00
|
|
|
|
2011-03-21 22:01:40 +08:00
|
|
|
/// FindTargetProgramPath - Return path of the target specific version of
|
|
|
|
/// ProgName. If it doesn't exist, return path of ProgName itself.
|
|
|
|
static std::string FindTargetProgramPath(const ToolChain &TheToolChain,
|
2011-05-16 21:35:02 +08:00
|
|
|
const std::string TripleString,
|
2011-03-21 22:01:40 +08:00
|
|
|
const char *ProgName) {
|
2011-05-16 21:35:02 +08:00
|
|
|
std::string Executable(TripleString + "-" + ProgName);
|
2011-03-21 22:01:40 +08:00
|
|
|
std::string Path(TheToolChain.GetProgramPath(Executable.c_str()));
|
|
|
|
if (Path != Executable)
|
|
|
|
return Path;
|
|
|
|
return TheToolChain.GetProgramPath(ProgName);
|
|
|
|
}
|
|
|
|
|
2009-09-10 09:21:05 +08:00
|
|
|
/// CheckPreprocessingOptions - Perform some validation of preprocessing
|
|
|
|
/// arguments that is shared with gcc.
|
|
|
|
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
|
2011-03-07 07:31:01 +08:00
|
|
|
if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_only_allowed_with)
|
2009-09-10 09:21:05 +08:00
|
|
|
<< A->getAsString(Args) << "-E";
|
|
|
|
}
|
|
|
|
|
2009-09-10 09:21:12 +08:00
|
|
|
/// CheckCodeGenerationOptions - Perform some validation of code generation
|
|
|
|
/// arguments that is shared with gcc.
|
|
|
|
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
|
|
|
|
// In gcc, only ARM checks this, but it seems reasonable to check universally.
|
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
|
|
|
|
options::OPT_mdynamic_no_pic))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_not_allowed_with)
|
2009-09-10 09:21:12 +08:00
|
|
|
<< A->getAsString(Args) << "-static";
|
|
|
|
}
|
|
|
|
|
2010-03-30 01:55:58 +08:00
|
|
|
// Quote target names for inclusion in GNU Make dependency files.
|
|
|
|
// Only the characters '$', '#', ' ', '\t' are quoted.
|
2011-07-23 18:55:15 +08:00
|
|
|
static void QuoteTarget(StringRef Target,
|
|
|
|
SmallVectorImpl<char> &Res) {
|
2010-03-30 01:55:58 +08:00
|
|
|
for (unsigned i = 0, e = Target.size(); i != e; ++i) {
|
|
|
|
switch (Target[i]) {
|
|
|
|
case ' ':
|
|
|
|
case '\t':
|
|
|
|
// Escape the preceding backslashes
|
|
|
|
for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
|
|
|
|
Res.push_back('\\');
|
|
|
|
|
|
|
|
// Escape the space/tab
|
|
|
|
Res.push_back('\\');
|
|
|
|
break;
|
|
|
|
case '$':
|
|
|
|
Res.push_back('$');
|
|
|
|
break;
|
|
|
|
case '#':
|
|
|
|
Res.push_back('\\');
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
Res.push_back(Target[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
static void AddLinkerInputs(const ToolChain &TC,
|
|
|
|
const InputInfoList &Inputs, const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) {
|
|
|
|
const Driver &D = TC.getDriver();
|
|
|
|
|
2011-02-19 13:33:51 +08:00
|
|
|
// Add extra linker input arguments which are not treated as inputs
|
|
|
|
// (constructed via -Xarch_).
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
|
|
|
|
if (!TC.HasNativeLLVMSupport()) {
|
|
|
|
// Don't try to pass LLVM inputs unless we have native support.
|
|
|
|
if (II.getType() == types::TY_LLVM_IR ||
|
|
|
|
II.getType() == types::TY_LTO_IR ||
|
|
|
|
II.getType() == types::TY_LLVM_BC ||
|
|
|
|
II.getType() == types::TY_LTO_BC)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_no_linker_llvm_support)
|
2010-09-17 08:24:54 +08:00
|
|
|
<< TC.getTripleString();
|
|
|
|
}
|
|
|
|
|
2010-09-17 08:45:02 +08:00
|
|
|
// Add filenames immediately.
|
|
|
|
if (II.isFilename()) {
|
2010-09-17 08:24:54 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2010-09-17 08:45:02 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, this is a linker input argument.
|
|
|
|
const Arg &A = II.getInputArg();
|
|
|
|
|
|
|
|
// Handle reserved library options.
|
|
|
|
if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
|
2010-09-17 09:20:05 +08:00
|
|
|
TC.AddCXXStdlibLibArgs(Args, CmdArgs);
|
2010-09-18 02:39:08 +08:00
|
|
|
} else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
|
|
|
|
TC.AddCCKextLibArgs(Args, CmdArgs);
|
2010-09-17 08:45:02 +08:00
|
|
|
} else
|
|
|
|
A.renderAsInput(Args, CmdArgs);
|
2010-09-17 08:24:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-16 07:02:42 +08:00
|
|
|
/// \brief Determine whether Objective-C automated reference counting is
|
|
|
|
/// enabled.
|
|
|
|
static bool isObjCAutoRefCount(const ArgList &Args) {
|
|
|
|
return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
|
|
|
|
}
|
|
|
|
|
2011-06-03 02:58:46 +08:00
|
|
|
static void addProfileRT(const ToolChain &TC, const ArgList &Args,
|
2011-06-28 03:15:03 +08:00
|
|
|
ArgStringList &CmdArgs,
|
|
|
|
llvm::Triple Triple) {
|
|
|
|
if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
|
|
|
|
Args.hasArg(options::OPT_fprofile_generate) ||
|
|
|
|
Args.hasArg(options::OPT_fcreate_profile) ||
|
|
|
|
Args.hasArg(options::OPT_coverage)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
|
|
|
|
// the link line. We cannot do the same thing because unlike gcov there is a
|
|
|
|
// libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
|
|
|
|
// not supported by old linkers.
|
2011-07-23 18:55:15 +08:00
|
|
|
Twine ProfileRT =
|
|
|
|
Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.a";
|
2011-06-28 03:15:03 +08:00
|
|
|
|
|
|
|
if (Triple.getOS() == llvm::Triple::Darwin) {
|
|
|
|
// On Darwin, if the static library doesn't exist try the dylib.
|
|
|
|
bool Exists;
|
|
|
|
if (llvm::sys::fs::exists(ProfileRT.str(), Exists) || !Exists)
|
|
|
|
ProfileRT =
|
2011-07-23 18:55:15 +08:00
|
|
|
Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.dylib";
|
2011-06-03 02:58:46 +08:00
|
|
|
}
|
2011-06-28 03:15:03 +08:00
|
|
|
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(ProfileRT));
|
2011-06-03 02:58:46 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
void Clang::AddPreprocessingOptions(const Driver &D,
|
2009-04-18 08:34:01 +08:00
|
|
|
const ArgList &Args,
|
2009-04-09 07:54:23 +08:00
|
|
|
ArgStringList &CmdArgs,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs) const {
|
|
|
|
Arg *A;
|
2009-06-09 05:48:20 +08:00
|
|
|
|
2009-09-10 09:21:05 +08:00
|
|
|
CheckPreprocessingOptions(D, Args);
|
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_C);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_CC);
|
2009-06-09 05:48:20 +08:00
|
|
|
|
|
|
|
// Handle dependency file generation.
|
2010-12-09 05:33:40 +08:00
|
|
|
if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
|
2009-04-09 07:54:23 +08:00
|
|
|
(A = Args.getLastArg(options::OPT_MD)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_MMD))) {
|
|
|
|
// Determine the output location.
|
|
|
|
const char *DepFile;
|
|
|
|
if (Output.getType() == types::TY_Dependencies) {
|
2010-08-02 10:38:21 +08:00
|
|
|
DepFile = Output.getFilename();
|
2009-04-09 07:54:23 +08:00
|
|
|
} else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
|
|
|
|
DepFile = MF->getValue(Args);
|
2009-11-19 11:26:40 +08:00
|
|
|
} else if (A->getOption().matches(options::OPT_M) ||
|
|
|
|
A->getOption().matches(options::OPT_MM)) {
|
2009-04-09 07:54:23 +08:00
|
|
|
DepFile = "-";
|
|
|
|
} else {
|
|
|
|
DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
|
|
|
|
}
|
|
|
|
CmdArgs.push_back("-dependency-file");
|
|
|
|
CmdArgs.push_back(DepFile);
|
|
|
|
|
2010-03-30 01:55:58 +08:00
|
|
|
// Add a default target if one wasn't specified.
|
2009-04-09 07:54:23 +08:00
|
|
|
if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
|
|
|
|
const char *DepTarget;
|
|
|
|
|
|
|
|
// If user provided -o, that is the dependency target, except
|
|
|
|
// when we are only generating a dependency file.
|
|
|
|
Arg *OutputOpt = Args.getLastArg(options::OPT_o);
|
|
|
|
if (OutputOpt && Output.getType() != types::TY_Dependencies) {
|
|
|
|
DepTarget = OutputOpt->getValue(Args);
|
|
|
|
} else {
|
|
|
|
// Otherwise derive from the base input.
|
|
|
|
//
|
|
|
|
// FIXME: This should use the computed output file location.
|
2010-12-18 08:19:12 +08:00
|
|
|
llvm::SmallString<128> P(Inputs[0].getBaseInput());
|
|
|
|
llvm::sys::path::replace_extension(P, "o");
|
|
|
|
DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CmdArgs.push_back("-MT");
|
2010-03-30 01:55:58 +08:00
|
|
|
llvm::SmallString<128> Quoted;
|
|
|
|
QuoteTarget(DepTarget, Quoted);
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(Quoted));
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
|
|
|
|
2009-11-19 11:26:40 +08:00
|
|
|
if (A->getOption().matches(options::OPT_M) ||
|
|
|
|
A->getOption().matches(options::OPT_MD))
|
2009-04-09 07:54:23 +08:00
|
|
|
CmdArgs.push_back("-sys-header-deps");
|
|
|
|
}
|
|
|
|
|
2011-07-13 03:35:15 +08:00
|
|
|
if (Args.hasArg(options::OPT_MG)) {
|
|
|
|
if (!A || A->getOption().matches(options::OPT_MD) ||
|
|
|
|
A->getOption().matches(options::OPT_MMD))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_mg_requires_m_or_mm);
|
2011-07-13 03:35:15 +08:00
|
|
|
CmdArgs.push_back("-MG");
|
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_MP);
|
2010-03-30 01:55:58 +08:00
|
|
|
|
|
|
|
// Convert all -MQ <target> args to -MT <quoted target>
|
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
|
|
|
|
options::OPT_MQ),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
2010-06-12 06:00:13 +08:00
|
|
|
const Arg *A = *it;
|
|
|
|
A->claim();
|
2010-03-30 01:55:58 +08:00
|
|
|
|
2010-06-12 06:00:13 +08:00
|
|
|
if (A->getOption().matches(options::OPT_MQ)) {
|
2010-03-30 01:55:58 +08:00
|
|
|
CmdArgs.push_back("-MT");
|
|
|
|
llvm::SmallString<128> Quoted;
|
2010-06-12 06:00:13 +08:00
|
|
|
QuoteTarget(A->getValue(Args), Quoted);
|
2010-03-30 01:55:58 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(Quoted));
|
|
|
|
|
|
|
|
// -MT flag - no change
|
|
|
|
} else {
|
2010-06-12 06:00:13 +08:00
|
|
|
A->render(Args, CmdArgs);
|
2010-03-30 01:55:58 +08:00
|
|
|
}
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-04-18 08:34:01 +08:00
|
|
|
// Add -i* options, and automatically translate to
|
|
|
|
// -include-pch/-include-pth for transparent PCH support. It's
|
|
|
|
// wonky, but we include looking for .gch so we can support seamless
|
|
|
|
// replacement into a build system already set up to be generating
|
|
|
|
// .gch files.
|
2010-10-01 00:53:47 +08:00
|
|
|
bool RenderedImplicitInclude = false;
|
2009-11-25 19:53:23 +08:00
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
|
|
|
const Arg *A = it;
|
2009-04-09 07:54:23 +08:00
|
|
|
|
|
|
|
if (A->getOption().matches(options::OPT_include)) {
|
2010-10-01 00:53:47 +08:00
|
|
|
bool IsFirstImplicitInclude = !RenderedImplicitInclude;
|
|
|
|
RenderedImplicitInclude = true;
|
|
|
|
|
2010-08-12 07:27:58 +08:00
|
|
|
// Use PCH if the user requested it.
|
2009-10-16 04:02:44 +08:00
|
|
|
bool UsePCH = D.CCCUsePCH;
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
bool FoundPTH = false;
|
2009-04-18 08:34:01 +08:00
|
|
|
bool FoundPCH = false;
|
2009-04-09 07:54:23 +08:00
|
|
|
llvm::sys::Path P(A->getValue(Args));
|
2011-01-10 10:34:13 +08:00
|
|
|
bool Exists;
|
2009-10-16 04:02:44 +08:00
|
|
|
if (UsePCH) {
|
2009-04-18 08:34:01 +08:00
|
|
|
P.appendSuffix("pch");
|
2011-01-10 10:34:13 +08:00
|
|
|
if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
|
2009-04-18 08:34:01 +08:00
|
|
|
FoundPCH = true;
|
2009-09-09 23:08:12 +08:00
|
|
|
else
|
2009-04-18 08:34:01 +08:00
|
|
|
P.eraseSuffix();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!FoundPCH) {
|
|
|
|
P.appendSuffix("pth");
|
2011-01-10 10:34:13 +08:00
|
|
|
if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
|
2009-04-09 07:54:23 +08:00
|
|
|
FoundPTH = true;
|
2009-04-18 08:34:01 +08:00
|
|
|
else
|
|
|
|
P.eraseSuffix();
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
|
|
|
|
2009-04-18 08:34:01 +08:00
|
|
|
if (!FoundPCH && !FoundPTH) {
|
|
|
|
P.appendSuffix("gch");
|
2011-01-10 10:34:13 +08:00
|
|
|
if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
|
2009-10-16 04:02:44 +08:00
|
|
|
FoundPCH = UsePCH;
|
|
|
|
FoundPTH = !UsePCH;
|
2009-04-18 08:34:01 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
else
|
2009-04-18 08:34:01 +08:00
|
|
|
P.eraseSuffix();
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
|
|
|
|
2009-04-18 08:34:01 +08:00
|
|
|
if (FoundPCH || FoundPTH) {
|
2010-10-01 00:53:47 +08:00
|
|
|
if (IsFirstImplicitInclude) {
|
|
|
|
A->claim();
|
|
|
|
if (UsePCH)
|
|
|
|
CmdArgs.push_back("-include-pch");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-include-pth");
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(P.str()));
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
// Ignore the PCH if not first on command line and emit warning.
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_pch_not_first_include)
|
2010-10-01 00:53:47 +08:00
|
|
|
<< P.str() << A->getAsString(Args);
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Not translated, render as usual.
|
|
|
|
A->claim();
|
|
|
|
A->render(Args, CmdArgs);
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
|
2011-07-28 12:45:53 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
|
|
|
|
options::OPT_index_header_map);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-09-15 07:12:35 +08:00
|
|
|
// Add C++ include arguments, if needed.
|
|
|
|
types::ID InputType = Inputs[0].getType();
|
2011-06-16 07:02:42 +08:00
|
|
|
if (types::isCXX(InputType)) {
|
|
|
|
bool ObjCXXAutoRefCount
|
|
|
|
= types::isObjC(InputType) && isObjCAutoRefCount(Args);
|
2011-08-19 08:30:14 +08:00
|
|
|
getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs,
|
2011-06-16 07:02:42 +08:00
|
|
|
ObjCXXAutoRefCount);
|
2011-06-22 05:12:29 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_stdlib_EQ);
|
2011-06-16 07:02:42 +08:00
|
|
|
}
|
2010-09-15 07:12:35 +08:00
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
// Add -Wp, and -Xassembler if using the preprocessor.
|
|
|
|
|
|
|
|
// FIXME: There is a very unfortunate problem here, some troubled
|
|
|
|
// souls abuse -Wp, to pass preprocessor options in gcc syntax. To
|
|
|
|
// really support that we would have to parse and then translate
|
|
|
|
// those options. :(
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
|
|
|
|
options::OPT_Xpreprocessor);
|
2009-10-29 09:53:44 +08:00
|
|
|
|
|
|
|
// -I- is a deprecated GCC feature, reject it.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_I_))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
|
2010-10-20 15:00:47 +08:00
|
|
|
|
|
|
|
// If we have a --sysroot, and don't have an explicit -isysroot flag, add an
|
|
|
|
// -isysroot to the CC1 invocation.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
|
|
|
|
if (!Args.hasArg(options::OPT_isysroot)) {
|
|
|
|
CmdArgs.push_back("-isysroot");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
|
|
|
|
2011-04-15 13:22:18 +08:00
|
|
|
/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
|
2009-09-10 14:49:20 +08:00
|
|
|
//
|
|
|
|
// FIXME: tblgen this.
|
2010-06-29 01:18:09 +08:00
|
|
|
static const char *getARMTargetCPU(const ArgList &Args,
|
|
|
|
const llvm::Triple &Triple) {
|
2009-09-10 14:49:20 +08:00
|
|
|
// FIXME: Warn on inconsistent use of -mcpu and -march.
|
2009-09-10 12:57:17 +08:00
|
|
|
|
|
|
|
// If we have -mcpu=, use that.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
|
|
|
|
return A->getValue(Args);
|
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef MArch;
|
2009-09-10 12:57:17 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
|
2010-06-29 01:18:09 +08:00
|
|
|
// Otherwise, if we have -march= choose the base CPU for that arch.
|
|
|
|
MArch = A->getValue(Args);
|
|
|
|
} else {
|
|
|
|
// Otherwise, use the Arch from the triple.
|
|
|
|
MArch = Triple.getArchName();
|
2009-09-10 12:57:17 +08:00
|
|
|
}
|
|
|
|
|
2010-06-29 01:18:09 +08:00
|
|
|
if (MArch == "armv2" || MArch == "armv2a")
|
|
|
|
return "arm2";
|
|
|
|
if (MArch == "armv3")
|
|
|
|
return "arm6";
|
|
|
|
if (MArch == "armv3m")
|
|
|
|
return "arm7m";
|
|
|
|
if (MArch == "armv4" || MArch == "armv4t")
|
|
|
|
return "arm7tdmi";
|
|
|
|
if (MArch == "armv5" || MArch == "armv5t")
|
|
|
|
return "arm10tdmi";
|
|
|
|
if (MArch == "armv5e" || MArch == "armv5te")
|
|
|
|
return "arm1026ejs";
|
|
|
|
if (MArch == "armv5tej")
|
|
|
|
return "arm926ej-s";
|
|
|
|
if (MArch == "armv6" || MArch == "armv6k")
|
|
|
|
return "arm1136jf-s";
|
|
|
|
if (MArch == "armv6j")
|
|
|
|
return "arm1136j-s";
|
|
|
|
if (MArch == "armv6z" || MArch == "armv6zk")
|
|
|
|
return "arm1176jzf-s";
|
|
|
|
if (MArch == "armv6t2")
|
|
|
|
return "arm1156t2-s";
|
|
|
|
if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
|
|
|
|
return "cortex-a8";
|
|
|
|
if (MArch == "armv7r" || MArch == "armv7-r")
|
|
|
|
return "cortex-r4";
|
|
|
|
if (MArch == "armv7m" || MArch == "armv7-m")
|
|
|
|
return "cortex-m3";
|
|
|
|
if (MArch == "ep9312")
|
|
|
|
return "ep9312";
|
|
|
|
if (MArch == "iwmmxt")
|
|
|
|
return "iwmmxt";
|
|
|
|
if (MArch == "xscale")
|
|
|
|
return "xscale";
|
2011-03-22 04:40:05 +08:00
|
|
|
if (MArch == "armv6m" || MArch == "armv6-m")
|
|
|
|
return "cortex-m0";
|
2010-06-29 01:18:09 +08:00
|
|
|
|
|
|
|
// If all else failed, return the most base CPU LLVM supports.
|
2009-09-10 12:57:17 +08:00
|
|
|
return "arm7tdmi";
|
|
|
|
}
|
|
|
|
|
2009-09-11 06:59:51 +08:00
|
|
|
/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
|
2009-09-10 14:49:20 +08:00
|
|
|
/// CPU.
|
|
|
|
//
|
|
|
|
// FIXME: This is redundant with -mcpu, why does LLVM use this.
|
|
|
|
// FIXME: tblgen this, or kill it!
|
2011-07-23 18:55:15 +08:00
|
|
|
static const char *getLLVMArchSuffixForARM(StringRef CPU) {
|
2009-09-10 14:49:20 +08:00
|
|
|
if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" ||
|
|
|
|
CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" ||
|
|
|
|
CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" ||
|
|
|
|
CPU == "arm940t" || CPU == "ep9312")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v4t";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
|
|
|
if (CPU == "arm10tdmi" || CPU == "arm1020t")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v5";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
|
|
|
if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" ||
|
|
|
|
CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" ||
|
|
|
|
CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" ||
|
|
|
|
CPU == "iwmmxt")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v5e";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
|
|
|
if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" ||
|
|
|
|
CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v6";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
|
|
|
if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v6t2";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
|
|
|
if (CPU == "cortex-a8" || CPU == "cortex-a9")
|
2009-09-11 06:59:51 +08:00
|
|
|
return "v7";
|
2009-09-10 14:49:20 +08:00
|
|
|
|
2009-09-11 06:59:51 +08:00
|
|
|
return "";
|
2009-09-10 14:49:20 +08:00
|
|
|
}
|
|
|
|
|
2009-11-17 14:37:03 +08:00
|
|
|
// FIXME: Move to target hook.
|
|
|
|
static bool isSignedCharDefault(const llvm::Triple &Triple) {
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
|
2011-05-24 23:40:46 +08:00
|
|
|
case llvm::Triple::arm:
|
2009-11-17 14:37:03 +08:00
|
|
|
case llvm::Triple::ppc:
|
|
|
|
case llvm::Triple::ppc64:
|
|
|
|
if (Triple.getOS() == llvm::Triple::Darwin)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
|
|
|
|
case llvm::Triple::systemz:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-10 12:57:17 +08:00
|
|
|
void Clang::AddARMTargetArgs(const ArgList &Args,
|
2011-03-18 01:10:06 +08:00
|
|
|
ArgStringList &CmdArgs,
|
|
|
|
bool KernelOrKext) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2010-06-29 01:18:09 +08:00
|
|
|
llvm::Triple Triple = getToolChain().getTriple();
|
2009-09-11 07:00:09 +08:00
|
|
|
|
2011-03-02 08:55:57 +08:00
|
|
|
// Disable movt generation, if requested.
|
|
|
|
#ifdef DISABLE_ARM_DARWIN_USE_MOVT
|
2011-03-23 00:48:17 +08:00
|
|
|
CmdArgs.push_back("-backend-option");
|
2011-03-02 08:55:57 +08:00
|
|
|
CmdArgs.push_back("-arm-darwin-use-movt=0");
|
|
|
|
#endif
|
|
|
|
|
2009-09-14 08:34:46 +08:00
|
|
|
// Select the ABI to use.
|
|
|
|
//
|
|
|
|
// FIXME: Support -meabi.
|
|
|
|
const char *ABIName = 0;
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
|
|
|
|
ABIName = A->getValue(Args);
|
|
|
|
} else {
|
|
|
|
// Select the default based on the platform.
|
2011-02-05 01:59:28 +08:00
|
|
|
switch(Triple.getEnvironment()) {
|
|
|
|
case llvm::Triple::GNUEABI:
|
2010-06-17 03:01:17 +08:00
|
|
|
ABIName = "aapcs-linux";
|
2011-02-05 01:59:28 +08:00
|
|
|
break;
|
|
|
|
case llvm::Triple::EABI:
|
2009-09-14 08:34:46 +08:00
|
|
|
ABIName = "aapcs";
|
2011-02-05 01:59:28 +08:00
|
|
|
break;
|
|
|
|
default:
|
2009-09-14 08:34:46 +08:00
|
|
|
ABIName = "apcs-gnu";
|
2011-02-05 01:59:28 +08:00
|
|
|
}
|
2009-09-14 08:34:46 +08:00
|
|
|
}
|
|
|
|
CmdArgs.push_back("-target-abi");
|
|
|
|
CmdArgs.push_back(ABIName);
|
|
|
|
|
2009-09-10 12:57:17 +08:00
|
|
|
// Set the CPU based on -march= and -mcpu=.
|
2009-12-18 14:30:12 +08:00
|
|
|
CmdArgs.push_back("-target-cpu");
|
2010-06-29 01:18:09 +08:00
|
|
|
CmdArgs.push_back(getARMTargetCPU(Args, Triple));
|
2009-09-10 12:57:17 +08:00
|
|
|
|
2009-09-11 07:00:09 +08:00
|
|
|
// Select the float ABI as determined by -msoft-float, -mhard-float, and
|
|
|
|
// -mfloat-abi=.
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef FloatABI;
|
2009-09-11 07:00:09 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
|
|
|
|
options::OPT_mhard_float,
|
|
|
|
options::OPT_mfloat_abi_EQ)) {
|
|
|
|
if (A->getOption().matches(options::OPT_msoft_float))
|
|
|
|
FloatABI = "soft";
|
|
|
|
else if (A->getOption().matches(options::OPT_mhard_float))
|
|
|
|
FloatABI = "hard";
|
|
|
|
else {
|
|
|
|
FloatABI = A->getValue(Args);
|
|
|
|
if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_invalid_mfloat_abi)
|
2009-09-11 07:00:09 +08:00
|
|
|
<< A->getAsString(Args);
|
|
|
|
FloatABI = "soft";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If unspecified, choose the default based on the platform.
|
|
|
|
if (FloatABI.empty()) {
|
2010-06-29 01:18:09 +08:00
|
|
|
const llvm::Triple &Triple = getToolChain().getTriple();
|
|
|
|
switch (Triple.getOS()) {
|
2009-09-11 07:00:09 +08:00
|
|
|
case llvm::Triple::Darwin: {
|
|
|
|
// Darwin defaults to "softfp" for v6 and v7.
|
|
|
|
//
|
|
|
|
// FIXME: Factor out an ARM class so we can cache the arch somewhere.
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef ArchName =
|
2010-06-29 01:18:09 +08:00
|
|
|
getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
|
2009-09-11 07:00:09 +08:00
|
|
|
if (ArchName.startswith("v6") || ArchName.startswith("v7"))
|
|
|
|
FloatABI = "softfp";
|
|
|
|
else
|
|
|
|
FloatABI = "soft";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-06-28 02:29:21 +08:00
|
|
|
case llvm::Triple::Linux: {
|
2011-02-05 01:59:28 +08:00
|
|
|
if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
|
2010-06-28 02:29:21 +08:00
|
|
|
FloatABI = "softfp";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// fall through
|
|
|
|
|
2009-09-11 07:00:09 +08:00
|
|
|
default:
|
2011-02-05 01:59:28 +08:00
|
|
|
switch(Triple.getEnvironment()) {
|
|
|
|
case llvm::Triple::GNUEABI:
|
|
|
|
FloatABI = "softfp";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::EABI:
|
|
|
|
// EABI is always AAPCS, and if it was not marked 'hard', it's softfp
|
|
|
|
FloatABI = "softfp";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Assume "soft", but warn the user we are guessing.
|
|
|
|
FloatABI = "soft";
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
|
2011-02-05 01:59:28 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-09-11 07:00:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FloatABI == "soft") {
|
|
|
|
// Floating point operations and argument passing are soft.
|
|
|
|
//
|
|
|
|
// FIXME: This changes CPP defines, we need -target-soft-float.
|
2009-11-30 16:42:00 +08:00
|
|
|
CmdArgs.push_back("-msoft-float");
|
2009-12-09 03:49:51 +08:00
|
|
|
CmdArgs.push_back("-mfloat-abi");
|
|
|
|
CmdArgs.push_back("soft");
|
2009-09-11 07:00:09 +08:00
|
|
|
} else if (FloatABI == "softfp") {
|
|
|
|
// Floating point operations are hard, but argument passing is soft.
|
2009-12-09 03:49:51 +08:00
|
|
|
CmdArgs.push_back("-mfloat-abi");
|
|
|
|
CmdArgs.push_back("soft");
|
2009-09-11 07:00:09 +08:00
|
|
|
} else {
|
|
|
|
// Floating point operations and argument passing are hard.
|
|
|
|
assert(FloatABI == "hard" && "Invalid float abi!");
|
2009-12-09 03:49:51 +08:00
|
|
|
CmdArgs.push_back("-mfloat-abi");
|
|
|
|
CmdArgs.push_back("hard");
|
2009-09-11 07:00:09 +08:00
|
|
|
}
|
2009-12-19 12:15:38 +08:00
|
|
|
|
|
|
|
// Set appropriate target features for floating point mode.
|
|
|
|
//
|
|
|
|
// FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
|
|
|
|
// yet (it uses the -mfloat-abi and -msoft-float options above), and it is
|
|
|
|
// stripped out by the ARM target.
|
|
|
|
|
|
|
|
// Use software floating point operations?
|
|
|
|
if (FloatABI == "soft") {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+soft-float");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use software floating point argument passing?
|
|
|
|
if (FloatABI != "hard") {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+soft-float-abi");
|
|
|
|
}
|
2009-12-22 07:28:17 +08:00
|
|
|
|
|
|
|
// Honor -mfpu=.
|
|
|
|
//
|
|
|
|
// FIXME: Centralize feature selection, defaulting shouldn't be also in the
|
|
|
|
// frontend target.
|
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef FPU = A->getValue(Args);
|
2009-12-22 07:28:17 +08:00
|
|
|
|
|
|
|
// Set the target features based on the FPU.
|
|
|
|
if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
|
|
|
|
// Disable any default FPU support.
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("-vfp2");
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("-vfp3");
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("-neon");
|
|
|
|
} else if (FPU == "vfp") {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+vfp2");
|
|
|
|
} else if (FPU == "vfp3") {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+vfp3");
|
|
|
|
} else if (FPU == "neon") {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+neon");
|
|
|
|
} else
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
|
2009-12-22 07:28:17 +08:00
|
|
|
}
|
2011-03-17 08:07:34 +08:00
|
|
|
|
|
|
|
// Setting -msoft-float effectively disables NEON because of the GCC
|
|
|
|
// implementation, although the same isn't true of VFP or VFP3.
|
|
|
|
if (FloatABI == "soft") {
|
2011-03-18 01:10:06 +08:00
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("-neon");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Kernel code has more strict alignment requirements.
|
|
|
|
if (KernelOrKext) {
|
2011-03-23 00:48:17 +08:00
|
|
|
CmdArgs.push_back("-backend-option");
|
2011-03-18 01:10:06 +08:00
|
|
|
CmdArgs.push_back("-arm-long-calls");
|
|
|
|
|
2011-03-23 00:48:17 +08:00
|
|
|
CmdArgs.push_back("-backend-option");
|
2011-03-18 01:10:06 +08:00
|
|
|
CmdArgs.push_back("-arm-strict-align");
|
2011-04-19 05:26:42 +08:00
|
|
|
|
|
|
|
// The kext linker doesn't know how to deal with movw/movt.
|
|
|
|
#ifndef DISABLE_ARM_DARWIN_USE_MOVT
|
|
|
|
CmdArgs.push_back("-backend-option");
|
|
|
|
CmdArgs.push_back("-arm-darwin-use-movt=0");
|
|
|
|
#endif
|
2011-03-17 08:07:34 +08:00
|
|
|
}
|
2011-08-26 08:26:29 +08:00
|
|
|
|
|
|
|
// Setting -mno-global-merge disables the codegen global merge pass. Setting
|
|
|
|
// -mglobal-merge has no effect as the pass is enabled by default.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
|
|
|
|
options::OPT_mno_global_merge)) {
|
|
|
|
if (A->getOption().matches(options::OPT_mno_global_merge))
|
|
|
|
CmdArgs.push_back("-mno-global-merge");
|
|
|
|
}
|
2009-09-10 12:57:17 +08:00
|
|
|
}
|
|
|
|
|
2010-03-02 10:41:08 +08:00
|
|
|
void Clang::AddMIPSTargetArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const {
|
|
|
|
const Driver &D = getToolChain().getDriver();
|
|
|
|
|
|
|
|
// Select the ABI to use.
|
|
|
|
const char *ABIName = 0;
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
|
|
|
|
ABIName = A->getValue(Args);
|
|
|
|
} else {
|
|
|
|
ABIName = "o32";
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdArgs.push_back("-target-abi");
|
|
|
|
CmdArgs.push_back(ABIName);
|
|
|
|
|
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef MArch = A->getValue(Args);
|
2010-03-02 10:41:08 +08:00
|
|
|
CmdArgs.push_back("-target-cpu");
|
|
|
|
|
|
|
|
if ((MArch == "r2000") || (MArch == "r3000"))
|
|
|
|
CmdArgs.push_back("mips1");
|
|
|
|
else if (MArch == "r6000")
|
|
|
|
CmdArgs.push_back("mips2");
|
|
|
|
else
|
2011-05-04 11:44:01 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(MArch));
|
2010-03-02 10:41:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Select the float ABI as determined by -msoft-float, -mhard-float, and
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef FloatABI;
|
2010-03-02 10:41:08 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
|
|
|
|
options::OPT_mhard_float)) {
|
|
|
|
if (A->getOption().matches(options::OPT_msoft_float))
|
|
|
|
FloatABI = "soft";
|
|
|
|
else if (A->getOption().matches(options::OPT_mhard_float))
|
|
|
|
FloatABI = "hard";
|
|
|
|
}
|
|
|
|
|
|
|
|
// If unspecified, choose the default based on the platform.
|
|
|
|
if (FloatABI.empty()) {
|
2010-04-08 23:44:22 +08:00
|
|
|
// Assume "soft", but warn the user we are guessing.
|
|
|
|
FloatABI = "soft";
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
|
2010-03-02 10:41:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (FloatABI == "soft") {
|
|
|
|
// Floating point operations and argument passing are soft.
|
|
|
|
//
|
|
|
|
// FIXME: This changes CPP defines, we need -target-soft-float.
|
|
|
|
CmdArgs.push_back("-msoft-float");
|
|
|
|
} else {
|
|
|
|
assert(FloatABI == "hard" && "Invalid float abi!");
|
|
|
|
CmdArgs.push_back("-mhard-float");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-10 01:21:19 +08:00
|
|
|
void Clang::AddSparcTargetArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const {
|
|
|
|
const Driver &D = getToolChain().getDriver();
|
|
|
|
|
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef MArch = A->getValue(Args);
|
2010-11-10 01:21:19 +08:00
|
|
|
CmdArgs.push_back("-target-cpu");
|
|
|
|
CmdArgs.push_back(MArch.str().c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Select the float ABI as determined by -msoft-float, -mhard-float, and
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef FloatABI;
|
2010-11-10 01:21:19 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
|
|
|
|
options::OPT_mhard_float)) {
|
|
|
|
if (A->getOption().matches(options::OPT_msoft_float))
|
|
|
|
FloatABI = "soft";
|
|
|
|
else if (A->getOption().matches(options::OPT_mhard_float))
|
|
|
|
FloatABI = "hard";
|
|
|
|
}
|
|
|
|
|
|
|
|
// If unspecified, choose the default based on the platform.
|
|
|
|
if (FloatABI.empty()) {
|
|
|
|
switch (getToolChain().getTriple().getOS()) {
|
|
|
|
default:
|
|
|
|
// Assume "soft", but warn the user we are guessing.
|
|
|
|
FloatABI = "soft";
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
|
2010-11-10 01:21:19 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FloatABI == "soft") {
|
|
|
|
// Floating point operations and argument passing are soft.
|
|
|
|
//
|
|
|
|
// FIXME: This changes CPP defines, we need -target-soft-float.
|
|
|
|
CmdArgs.push_back("-msoft-float");
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back("+soft-float");
|
|
|
|
} else {
|
|
|
|
assert(FloatABI == "hard" && "Invalid float abi!");
|
|
|
|
CmdArgs.push_back("-mhard-float");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-10 06:33:08 +08:00
|
|
|
void Clang::AddX86TargetArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2009-09-11 06:59:57 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_mred_zone,
|
|
|
|
options::OPT_mno_red_zone,
|
|
|
|
true) ||
|
|
|
|
Args.hasArg(options::OPT_mkernel) ||
|
|
|
|
Args.hasArg(options::OPT_fapple_kext))
|
2009-11-21 06:21:36 +08:00
|
|
|
CmdArgs.push_back("-disable-red-zone");
|
2009-09-11 06:59:57 +08:00
|
|
|
|
|
|
|
if (Args.hasFlag(options::OPT_msoft_float,
|
|
|
|
options::OPT_mno_soft_float,
|
|
|
|
false))
|
2009-11-21 06:21:36 +08:00
|
|
|
CmdArgs.push_back("-no-implicit-float");
|
2009-09-11 06:59:57 +08:00
|
|
|
|
2009-11-15 06:04:54 +08:00
|
|
|
const char *CPUName = 0;
|
2009-09-10 06:33:08 +08:00
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef(A->getValue(Args)) == "native") {
|
2009-11-15 06:04:54 +08:00
|
|
|
// FIXME: Reject attempts to use -march=native unless the target matches
|
|
|
|
// the host.
|
|
|
|
//
|
|
|
|
// FIXME: We should also incorporate the detected target features for use
|
|
|
|
// with -native.
|
|
|
|
std::string CPU = llvm::sys::getHostCPUName();
|
|
|
|
if (!CPU.empty())
|
|
|
|
CPUName = Args.MakeArgString(CPU);
|
|
|
|
} else
|
|
|
|
CPUName = A->getValue(Args);
|
|
|
|
}
|
2009-09-10 06:33:08 +08:00
|
|
|
|
2009-11-15 06:04:54 +08:00
|
|
|
// Select the default CPU if none was given (or detection failed).
|
|
|
|
if (!CPUName) {
|
2009-09-10 06:33:08 +08:00
|
|
|
// FIXME: Need target hooks.
|
2010-01-30 23:01:47 +08:00
|
|
|
if (getToolChain().getOS().startswith("darwin")) {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2009-11-15 06:04:54 +08:00
|
|
|
CPUName = "core2";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2009-11-15 06:04:54 +08:00
|
|
|
CPUName = "yonah";
|
2010-04-12 03:29:39 +08:00
|
|
|
} else if (getToolChain().getOS().startswith("haiku")) {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2010-04-12 03:29:39 +08:00
|
|
|
CPUName = "x86-64";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2010-04-12 03:29:39 +08:00
|
|
|
CPUName = "i586";
|
2010-08-02 07:13:54 +08:00
|
|
|
} else if (getToolChain().getOS().startswith("openbsd")) {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2010-08-02 07:13:54 +08:00
|
|
|
CPUName = "x86-64";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2010-08-02 07:13:54 +08:00
|
|
|
CPUName = "i486";
|
2011-03-02 02:11:37 +08:00
|
|
|
} else if (getToolChain().getOS().startswith("freebsd")) {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2011-03-02 02:11:37 +08:00
|
|
|
CPUName = "x86-64";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2011-03-02 02:11:37 +08:00
|
|
|
CPUName = "i486";
|
2011-02-03 02:59:27 +08:00
|
|
|
} else if (getToolChain().getOS().startswith("netbsd")) {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2011-02-03 02:59:27 +08:00
|
|
|
CPUName = "x86-64";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2011-02-03 02:59:27 +08:00
|
|
|
CPUName = "i486";
|
2009-09-10 06:33:08 +08:00
|
|
|
} else {
|
2011-05-31 23:58:55 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86_64)
|
2009-11-15 06:04:54 +08:00
|
|
|
CPUName = "x86-64";
|
2011-05-31 23:58:55 +08:00
|
|
|
else if (getToolChain().getArch() == llvm::Triple::x86)
|
2009-11-15 06:04:54 +08:00
|
|
|
CPUName = "pentium4";
|
2009-09-10 06:33:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-15 06:04:54 +08:00
|
|
|
if (CPUName) {
|
2009-12-18 14:30:12 +08:00
|
|
|
CmdArgs.push_back("-target-cpu");
|
2009-11-15 06:04:54 +08:00
|
|
|
CmdArgs.push_back(CPUName);
|
|
|
|
}
|
|
|
|
|
2011-07-02 08:34:19 +08:00
|
|
|
// The required algorithm here is slightly strange: the options are applied
|
|
|
|
// in order (so -mno-sse -msse2 disables SSE3), but any option that gets
|
|
|
|
// directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
|
|
|
|
// is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
|
|
|
|
// former correctly, but not the latter; handle directly-overridden
|
|
|
|
// attributes here.
|
|
|
|
llvm::StringMap<unsigned> PrevFeature;
|
|
|
|
std::vector<const char*> Features;
|
2009-11-25 19:53:23 +08:00
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef Name = (*it)->getOption().getName();
|
2010-06-12 06:00:13 +08:00
|
|
|
(*it)->claim();
|
2009-09-10 06:33:08 +08:00
|
|
|
|
2009-11-25 19:53:23 +08:00
|
|
|
// Skip over "-m".
|
|
|
|
assert(Name.startswith("-m") && "Invalid feature name.");
|
|
|
|
Name = Name.substr(2);
|
2009-09-10 06:33:08 +08:00
|
|
|
|
2009-11-25 19:53:23 +08:00
|
|
|
bool IsNegative = Name.startswith("no-");
|
|
|
|
if (IsNegative)
|
|
|
|
Name = Name.substr(3);
|
2009-09-10 06:33:08 +08:00
|
|
|
|
2011-07-02 08:34:19 +08:00
|
|
|
unsigned& Prev = PrevFeature[Name];
|
|
|
|
if (Prev)
|
|
|
|
Features[Prev - 1] = 0;
|
|
|
|
Prev = Features.size() + 1;
|
|
|
|
Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
|
|
|
|
}
|
|
|
|
for (unsigned i = 0; i < Features.size(); i++) {
|
|
|
|
if (Features[i]) {
|
|
|
|
CmdArgs.push_back("-target-feature");
|
|
|
|
CmdArgs.push_back(Features[i]);
|
|
|
|
}
|
2009-09-10 06:33:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-19 08:30:14 +08:00
|
|
|
static bool
|
2011-06-22 08:53:57 +08:00
|
|
|
shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion,
|
2011-02-28 08:44:51 +08:00
|
|
|
const llvm::Triple &Triple) {
|
|
|
|
// We use the zero-cost exception tables for Objective-C if the non-fragile
|
|
|
|
// ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
|
|
|
|
// later.
|
|
|
|
|
2011-06-22 08:53:57 +08:00
|
|
|
if (objcABIVersion >= 2)
|
2011-02-28 08:44:51 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
if (Triple.getOS() != llvm::Triple::Darwin)
|
|
|
|
return false;
|
|
|
|
|
2011-07-02 08:20:22 +08:00
|
|
|
return (!Triple.isMacOSXVersionLT(10,5) &&
|
2011-02-28 08:44:51 +08:00
|
|
|
(Triple.getArch() == llvm::Triple::x86_64 ||
|
2011-08-19 08:30:14 +08:00
|
|
|
Triple.getArch() == llvm::Triple::arm));
|
2011-02-28 08:44:51 +08:00
|
|
|
}
|
|
|
|
|
2011-02-28 10:27:16 +08:00
|
|
|
/// addExceptionArgs - Adds exception related arguments to the driver command
|
|
|
|
/// arguments. There's a master flag, -fexceptions and also language specific
|
|
|
|
/// flags to enable/disable C++ and Objective-C exceptions.
|
|
|
|
/// This makes it possible to for example disable C++ exceptions but enable
|
|
|
|
/// Objective-C exceptions.
|
|
|
|
static void addExceptionArgs(const ArgList &Args, types::ID InputType,
|
|
|
|
const llvm::Triple &Triple,
|
|
|
|
bool KernelOrKext, bool IsRewriter,
|
2011-06-22 08:53:57 +08:00
|
|
|
unsigned objcABIVersion,
|
2011-02-28 10:27:16 +08:00
|
|
|
ArgStringList &CmdArgs) {
|
|
|
|
if (KernelOrKext)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Exceptions are enabled by default.
|
|
|
|
bool ExceptionsEnabled = true;
|
|
|
|
|
|
|
|
// This keeps track of whether exceptions were explicitly turned on or off.
|
|
|
|
bool DidHaveExplicitExceptionFlag = false;
|
|
|
|
|
2009-10-01 21:33:33 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
|
|
|
|
options::OPT_fno_exceptions)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fexceptions))
|
2011-02-28 10:27:16 +08:00
|
|
|
ExceptionsEnabled = true;
|
2011-08-19 08:30:14 +08:00
|
|
|
else
|
2011-02-28 10:27:16 +08:00
|
|
|
ExceptionsEnabled = false;
|
|
|
|
|
|
|
|
DidHaveExplicitExceptionFlag = true;
|
2009-10-01 21:33:33 +08:00
|
|
|
}
|
2010-09-15 07:12:31 +08:00
|
|
|
|
2011-02-28 10:27:16 +08:00
|
|
|
bool ShouldUseExceptionTables = false;
|
|
|
|
|
|
|
|
// Exception tables and cleanups can be enabled with -fexceptions even if the
|
|
|
|
// language itself doesn't support exceptions.
|
|
|
|
if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
|
|
|
|
ShouldUseExceptionTables = true;
|
|
|
|
|
2011-03-18 07:28:31 +08:00
|
|
|
// Obj-C exceptions are enabled by default, regardless of -fexceptions. This
|
|
|
|
// is not necessarily sensible, but follows GCC.
|
|
|
|
if (types::isObjC(InputType) &&
|
2011-08-19 08:30:14 +08:00
|
|
|
Args.hasFlag(options::OPT_fobjc_exceptions,
|
2011-03-18 07:28:31 +08:00
|
|
|
options::OPT_fno_objc_exceptions,
|
|
|
|
true)) {
|
|
|
|
CmdArgs.push_back("-fobjc-exceptions");
|
|
|
|
|
2011-08-19 08:30:14 +08:00
|
|
|
ShouldUseExceptionTables |=
|
2011-06-22 08:53:57 +08:00
|
|
|
shouldUseExceptionTablesForObjCExceptions(objcABIVersion, Triple);
|
2011-02-28 10:27:16 +08:00
|
|
|
}
|
2009-10-02 04:30:46 +08:00
|
|
|
|
2011-02-28 10:27:16 +08:00
|
|
|
if (types::isCXX(InputType)) {
|
|
|
|
bool CXXExceptionsEnabled = ExceptionsEnabled;
|
2010-09-15 07:12:31 +08:00
|
|
|
|
2011-08-19 08:30:14 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
|
|
|
|
options::OPT_fno_cxx_exceptions,
|
2011-02-28 10:27:16 +08:00
|
|
|
options::OPT_fexceptions,
|
|
|
|
options::OPT_fno_exceptions)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fcxx_exceptions))
|
|
|
|
CXXExceptionsEnabled = true;
|
2011-02-28 15:25:18 +08:00
|
|
|
else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
|
2011-02-28 10:27:16 +08:00
|
|
|
CXXExceptionsEnabled = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CXXExceptionsEnabled) {
|
|
|
|
CmdArgs.push_back("-fcxx-exceptions");
|
|
|
|
|
|
|
|
ShouldUseExceptionTables = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ShouldUseExceptionTables)
|
|
|
|
CmdArgs.push_back("-fexceptions");
|
2009-10-01 21:33:33 +08:00
|
|
|
}
|
|
|
|
|
2011-05-03 01:43:32 +08:00
|
|
|
static bool ShouldDisableCFI(const ArgList &Args,
|
|
|
|
const ToolChain &TC) {
|
2011-05-18 00:26:17 +08:00
|
|
|
if (TC.getTriple().getOS() == llvm::Triple::Darwin) {
|
|
|
|
// The native darwin assembler doesn't support cfi directives, so
|
2011-05-18 03:06:58 +08:00
|
|
|
// we disable them if we think the .s file will be passed to it.
|
2011-05-18 00:26:17 +08:00
|
|
|
|
|
|
|
// FIXME: Duplicated code with ToolChains.cpp
|
|
|
|
// FIXME: This doesn't belong here, but ideally we will support static soon
|
|
|
|
// anyway.
|
|
|
|
bool HasStatic = (Args.hasArg(options::OPT_mkernel) ||
|
|
|
|
Args.hasArg(options::OPT_static) ||
|
|
|
|
Args.hasArg(options::OPT_fapple_kext));
|
|
|
|
bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic;
|
|
|
|
bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
|
|
|
|
options::OPT_no_integrated_as,
|
|
|
|
IsIADefault);
|
|
|
|
bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
|
|
|
|
options::OPT_fno_dwarf2_cfi_asm,
|
|
|
|
UseIntegratedAs);
|
|
|
|
return !UseCFI;
|
|
|
|
}
|
|
|
|
|
|
|
|
// For now we assume that every other assembler support CFI.
|
|
|
|
return false;
|
2011-05-03 01:43:32 +08:00
|
|
|
}
|
|
|
|
|
2011-05-06 22:35:16 +08:00
|
|
|
/// \brief Check whether the given input tree contains any compilation actions.
|
|
|
|
static bool ContainsCompileAction(const Action *A) {
|
2011-07-23 18:55:15 +08:00
|
|
|
if (isa<CompileJobAction>(A))
|
2011-05-06 22:35:16 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
|
|
|
|
if (ContainsCompileAction(*it))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Check if -relax-all should be passed to the internal assembler.
|
|
|
|
/// This is done by default when compiling non-assembler source with -O0.
|
|
|
|
static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
|
|
|
|
bool RelaxDefault = true;
|
|
|
|
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_O_Group))
|
|
|
|
RelaxDefault = A->getOption().matches(options::OPT_O0);
|
|
|
|
|
|
|
|
if (RelaxDefault) {
|
|
|
|
RelaxDefault = false;
|
|
|
|
for (ActionList::const_iterator it = C.getActions().begin(),
|
|
|
|
ie = C.getActions().end(); it != ie; ++it) {
|
|
|
|
if (ContainsCompileAction(*it)) {
|
|
|
|
RelaxDefault = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
|
|
|
|
RelaxDefault);
|
|
|
|
}
|
|
|
|
|
2009-03-18 14:00:36 +08:00
|
|
|
void Clang::ConstructJob(Compilation &C, const JobAction &JA,
|
2009-03-18 15:06:02 +08:00
|
|
|
const InputInfo &Output,
|
2009-03-18 14:07:59 +08:00
|
|
|
const InputInfoList &Inputs,
|
2009-03-18 18:01:51 +08:00
|
|
|
const ArgList &Args,
|
2009-03-18 14:00:36 +08:00
|
|
|
const char *LinkingOutput) const {
|
2010-03-20 12:52:14 +08:00
|
|
|
bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
|
|
|
|
options::OPT_fapple_kext);
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-03-18 16:07:30 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2009-04-01 04:53:55 +08:00
|
|
|
assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
|
|
|
|
|
2009-12-12 07:00:49 +08:00
|
|
|
// Invoke ourselves in -cc1 mode.
|
|
|
|
//
|
|
|
|
// FIXME: Implement custom jobs for internal actions.
|
|
|
|
CmdArgs.push_back("-cc1");
|
|
|
|
|
2009-10-31 02:12:20 +08:00
|
|
|
// Add the "effective" target triple.
|
2009-04-01 01:35:15 +08:00
|
|
|
CmdArgs.push_back("-triple");
|
2010-08-24 06:35:37 +08:00
|
|
|
std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
|
2009-10-31 02:12:20 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(TripleStr));
|
2009-09-10 14:49:20 +08:00
|
|
|
|
2009-10-31 02:12:20 +08:00
|
|
|
// Select the appropriate action.
|
2010-07-20 03:44:22 +08:00
|
|
|
bool IsRewriter = false;
|
2009-03-18 18:01:51 +08:00
|
|
|
if (isa<AnalyzeJobAction>(JA)) {
|
|
|
|
assert(JA.getType() == types::TY_Plist && "Invalid output type.");
|
|
|
|
CmdArgs.push_back("-analyze");
|
|
|
|
} else if (isa<PreprocessJobAction>(JA)) {
|
2009-03-30 14:36:42 +08:00
|
|
|
if (Output.getType() == types::TY_Dependencies)
|
|
|
|
CmdArgs.push_back("-Eonly");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-E");
|
2010-02-03 11:07:56 +08:00
|
|
|
} else if (isa<AssembleJobAction>(JA)) {
|
|
|
|
CmdArgs.push_back("-emit-obj");
|
2010-05-27 14:18:05 +08:00
|
|
|
|
2011-05-06 22:35:16 +08:00
|
|
|
if (UseRelaxAll(C, Args))
|
2010-05-27 14:18:05 +08:00
|
|
|
CmdArgs.push_back("-mrelax-all");
|
2010-08-25 00:47:49 +08:00
|
|
|
|
2010-10-19 06:36:15 +08:00
|
|
|
// When using an integrated assembler, translate -Wa, and -Xassembler
|
|
|
|
// options.
|
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
|
|
|
const Arg *A = *it;
|
|
|
|
A->claim();
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef Value = A->getValue(Args, i);
|
2010-10-19 06:36:15 +08:00
|
|
|
|
|
|
|
if (Value == "-force_cpusubtype_ALL") {
|
|
|
|
// Do nothing, this is the default and we don't support anything else.
|
2010-10-29 04:36:23 +08:00
|
|
|
} else if (Value == "-L") {
|
2011-03-29 06:49:28 +08:00
|
|
|
CmdArgs.push_back("-msave-temp-labels");
|
2011-05-20 04:46:39 +08:00
|
|
|
} else if (Value == "--fatal-warnings") {
|
2011-05-20 02:42:29 +08:00
|
|
|
CmdArgs.push_back("-mllvm");
|
|
|
|
CmdArgs.push_back("-fatal-assembler-warnings");
|
2011-06-21 08:14:18 +08:00
|
|
|
} else if (Value == "--noexecstack") {
|
|
|
|
CmdArgs.push_back("-mnoexecstack");
|
2010-10-19 06:36:15 +08:00
|
|
|
} else {
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_unsupported_option_argument)
|
2010-10-19 06:36:15 +08:00
|
|
|
<< A->getOption().getName() << Value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-11-20 00:23:35 +08:00
|
|
|
|
|
|
|
// Also ignore explicit -force_cpusubtype_ALL option.
|
|
|
|
(void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
|
2009-03-18 18:01:51 +08:00
|
|
|
} else if (isa<PrecompileJobAction>(JA)) {
|
2010-08-12 07:27:58 +08:00
|
|
|
// Use PCH if the user requested it.
|
2009-10-16 04:02:44 +08:00
|
|
|
bool UsePCH = D.CCCUsePCH;
|
|
|
|
|
|
|
|
if (UsePCH)
|
2009-04-18 08:34:01 +08:00
|
|
|
CmdArgs.push_back("-emit-pch");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-emit-pth");
|
2009-03-18 18:01:51 +08:00
|
|
|
} else {
|
|
|
|
assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
if (JA.getType() == types::TY_Nothing) {
|
|
|
|
CmdArgs.push_back("-fsyntax-only");
|
2010-06-08 07:28:45 +08:00
|
|
|
} else if (JA.getType() == types::TY_LLVM_IR ||
|
|
|
|
JA.getType() == types::TY_LTO_IR) {
|
2009-03-18 18:01:51 +08:00
|
|
|
CmdArgs.push_back("-emit-llvm");
|
2010-06-08 07:28:45 +08:00
|
|
|
} else if (JA.getType() == types::TY_LLVM_BC ||
|
|
|
|
JA.getType() == types::TY_LTO_BC) {
|
2009-03-18 18:01:51 +08:00
|
|
|
CmdArgs.push_back("-emit-llvm-bc");
|
|
|
|
} else if (JA.getType() == types::TY_PP_Asm) {
|
2009-09-17 08:47:53 +08:00
|
|
|
CmdArgs.push_back("-S");
|
2009-09-02 00:57:46 +08:00
|
|
|
} else if (JA.getType() == types::TY_AST) {
|
|
|
|
CmdArgs.push_back("-emit-pch");
|
2010-02-11 11:16:21 +08:00
|
|
|
} else if (JA.getType() == types::TY_RewrittenObjC) {
|
|
|
|
CmdArgs.push_back("-rewrite-objc");
|
2010-07-20 03:44:22 +08:00
|
|
|
IsRewriter = true;
|
2010-02-11 11:16:21 +08:00
|
|
|
} else {
|
|
|
|
assert(JA.getType() == types::TY_PP_Asm &&
|
|
|
|
"Unexpected output type!");
|
2009-03-18 18:01:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// The make clang go fast button.
|
|
|
|
CmdArgs.push_back("-disable-free");
|
|
|
|
|
2010-02-13 11:50:24 +08:00
|
|
|
// Disable the verification pass in -asserts builds.
|
|
|
|
#ifdef NDEBUG
|
|
|
|
CmdArgs.push_back("-disable-llvm-verifier");
|
|
|
|
#endif
|
|
|
|
|
2009-04-08 13:11:16 +08:00
|
|
|
// Set the main file name, so that debug info works even with
|
|
|
|
// -save-temps.
|
|
|
|
CmdArgs.push_back("-main-file-name");
|
|
|
|
CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
|
|
|
|
|
2009-04-09 02:03:55 +08:00
|
|
|
// Some flags which affect the language (via preprocessor
|
|
|
|
// defines). See darwin::CC1::AddCPPArgs.
|
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
CmdArgs.push_back("-static-define");
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
if (isa<AnalyzeJobAction>(JA)) {
|
2009-09-25 13:55:59 +08:00
|
|
|
// Enable region store model by default.
|
|
|
|
CmdArgs.push_back("-analyzer-store=region");
|
|
|
|
|
2009-12-08 06:26:14 +08:00
|
|
|
// Treat blocks as analysis entry points.
|
|
|
|
CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
|
|
|
|
|
2011-03-24 08:28:47 +08:00
|
|
|
CmdArgs.push_back("-analyzer-eagerly-assume");
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
// Add default argument set.
|
2009-05-22 08:38:15 +08:00
|
|
|
if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
|
2011-02-15 15:42:33 +08:00
|
|
|
CmdArgs.push_back("-analyzer-checker=core");
|
2011-03-24 08:28:47 +08:00
|
|
|
CmdArgs.push_back("-analyzer-checker=deadcode");
|
|
|
|
CmdArgs.push_back("-analyzer-checker=security");
|
|
|
|
|
2011-02-15 15:42:33 +08:00
|
|
|
if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
|
|
|
|
CmdArgs.push_back("-analyzer-checker=unix");
|
|
|
|
|
2011-03-24 08:28:47 +08:00
|
|
|
if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
|
|
|
|
CmdArgs.push_back("-analyzer-checker=osx");
|
2009-05-22 08:38:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set the output format. The default is plist, for (lame) historical
|
|
|
|
// reasons.
|
|
|
|
CmdArgs.push_back("-analyzer-output");
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("plist");
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2010-03-23 06:32:05 +08:00
|
|
|
// Disable the presentation of standard compiler warnings when
|
|
|
|
// using --analyze. We only want to show static analyzer diagnostics
|
|
|
|
// or frontend errors.
|
|
|
|
CmdArgs.push_back("-w");
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
// Add -Xanalyzer arguments when running as analyzer.
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
|
|
|
|
2009-09-10 09:21:12 +08:00
|
|
|
CheckCodeGenerationOptions(D, Args);
|
|
|
|
|
2009-04-30 02:32:25 +08:00
|
|
|
// Perform argument translation for LLVM backend. This
|
|
|
|
// takes some care in reconciling with llvm-gcc. The
|
|
|
|
// issue is that llvm-gcc translates these options based on
|
|
|
|
// the values in cc1, whereas we are processing based on
|
|
|
|
// the driver arguments.
|
2009-04-08 11:03:23 +08:00
|
|
|
|
2009-04-30 02:32:25 +08:00
|
|
|
// This comes from the default translation the driver + cc1
|
|
|
|
// would do to enable flag_pic.
|
|
|
|
//
|
|
|
|
// FIXME: Centralize this code.
|
|
|
|
bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
|
|
|
|
Args.hasArg(options::OPT_fpic) ||
|
|
|
|
Args.hasArg(options::OPT_fPIE) ||
|
|
|
|
Args.hasArg(options::OPT_fpie));
|
|
|
|
bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
|
|
|
|
Args.hasArg(options::OPT_static));
|
|
|
|
const char *Model = getToolChain().GetForcedPicModel();
|
|
|
|
if (!Model) {
|
|
|
|
if (Args.hasArg(options::OPT_mdynamic_no_pic))
|
|
|
|
Model = "dynamic-no-pic";
|
|
|
|
else if (PICDisabled)
|
|
|
|
Model = "static";
|
|
|
|
else if (PICEnabled)
|
|
|
|
Model = "pic";
|
2009-03-18 18:01:51 +08:00
|
|
|
else
|
2009-04-30 02:32:25 +08:00
|
|
|
Model = getToolChain().GetDefaultRelocationModel();
|
|
|
|
}
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef(Model) != "pic") {
|
2009-11-29 15:18:39 +08:00
|
|
|
CmdArgs.push_back("-mrelocation-model");
|
|
|
|
CmdArgs.push_back(Model);
|
|
|
|
}
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2009-04-30 02:32:25 +08:00
|
|
|
// Infer the __PIC__ value.
|
|
|
|
//
|
|
|
|
// FIXME: This isn't quite right on Darwin, which always sets
|
|
|
|
// __PIC__=2.
|
|
|
|
if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
|
2009-11-29 10:39:08 +08:00
|
|
|
CmdArgs.push_back("-pic-level");
|
|
|
|
CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
|
2009-04-30 02:32:25 +08:00
|
|
|
}
|
2009-11-29 15:18:39 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fmerge_all_constants,
|
|
|
|
options::OPT_fno_merge_all_constants))
|
2011-04-09 02:06:54 +08:00
|
|
|
CmdArgs.push_back("-fno-merge-all-constants");
|
2009-11-29 15:18:39 +08:00
|
|
|
|
|
|
|
// LLVM Code Generator Options.
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2011-02-10 01:54:19 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
|
|
|
|
CmdArgs.push_back("-mregparm");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2011-03-02 01:40:53 +08:00
|
|
|
if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
|
|
|
|
CmdArgs.push_back("-mrtd");
|
|
|
|
|
2009-04-30 02:32:25 +08:00
|
|
|
// FIXME: Set --enable-unsafe-fp-math.
|
2009-08-06 03:47:38 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
|
|
|
|
options::OPT_fomit_frame_pointer))
|
2009-11-29 15:18:39 +08:00
|
|
|
CmdArgs.push_back("-mdisable-fp-elim");
|
2009-04-30 02:32:25 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
|
2009-11-29 15:18:39 +08:00
|
|
|
options::OPT_fno_zero_initialized_in_bss))
|
|
|
|
CmdArgs.push_back("-mno-zero-initialized-in-bss");
|
2011-02-04 10:20:39 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fstrict_aliasing,
|
|
|
|
options::OPT_fno_strict_aliasing,
|
|
|
|
getToolChain().IsStrictAliasingDefault()))
|
2010-10-15 06:36:56 +08:00
|
|
|
CmdArgs.push_back("-relaxed-aliasing");
|
2010-05-15 06:00:22 +08:00
|
|
|
|
|
|
|
// Decide whether to use verbose asm. Verbose assembly is the default on
|
|
|
|
// toolchains which have the integrated assembler on by default.
|
|
|
|
bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
|
|
|
|
if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
|
2010-10-21 11:16:25 +08:00
|
|
|
IsVerboseAsmDefault) ||
|
2010-05-15 06:00:22 +08:00
|
|
|
Args.hasArg(options::OPT_dA))
|
2009-11-29 15:18:39 +08:00
|
|
|
CmdArgs.push_back("-masm-verbose");
|
2010-05-15 06:00:22 +08:00
|
|
|
|
2009-11-29 15:18:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
|
|
|
|
CmdArgs.push_back("-mdebug-pass");
|
|
|
|
CmdArgs.push_back("Structure");
|
|
|
|
}
|
|
|
|
if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
|
|
|
|
CmdArgs.push_back("-mdebug-pass");
|
|
|
|
CmdArgs.push_back("Arguments");
|
|
|
|
}
|
2009-09-16 14:17:29 +08:00
|
|
|
|
2010-02-19 10:45:38 +08:00
|
|
|
// Enable -mconstructor-aliases except on darwin, where we have to
|
|
|
|
// work around a linker bug; see <rdar://problem/7651567>.
|
|
|
|
if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin)
|
|
|
|
CmdArgs.push_back("-mconstructor-aliases");
|
2011-02-17 16:50:50 +08:00
|
|
|
|
2011-03-18 10:56:14 +08:00
|
|
|
// Darwin's kernel doesn't support guard variables; just die if we
|
|
|
|
// try to use them.
|
|
|
|
if (KernelOrKext &&
|
|
|
|
getToolChain().getTriple().getOS() == llvm::Triple::Darwin)
|
|
|
|
CmdArgs.push_back("-fforbid-guard-variables");
|
|
|
|
|
2011-02-01 23:15:22 +08:00
|
|
|
if (Args.hasArg(options::OPT_mms_bitfields)) {
|
|
|
|
CmdArgs.push_back("-mms-bitfields");
|
|
|
|
}
|
2010-02-19 10:45:38 +08:00
|
|
|
|
2009-09-16 14:17:29 +08:00
|
|
|
// This is a coarse approximation of what llvm-gcc actually does, both
|
|
|
|
// -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
|
|
|
|
// complicated ways.
|
|
|
|
bool AsynchronousUnwindTables =
|
|
|
|
Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
|
|
|
|
options::OPT_fno_asynchronous_unwind_tables,
|
|
|
|
getToolChain().IsUnwindTablesDefault() &&
|
2010-03-20 12:52:14 +08:00
|
|
|
!KernelOrKext);
|
2009-09-16 14:17:29 +08:00
|
|
|
if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
|
|
|
|
AsynchronousUnwindTables))
|
2009-11-29 15:18:39 +08:00
|
|
|
CmdArgs.push_back("-munwind-tables");
|
|
|
|
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
|
|
|
|
CmdArgs.push_back("-mlimit-float-precision");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
2009-04-30 02:32:25 +08:00
|
|
|
|
2009-05-06 11:16:41 +08:00
|
|
|
// FIXME: Handle -mtune=.
|
|
|
|
(void) Args.hasArg(options::OPT_mtune_EQ);
|
2009-04-30 02:32:25 +08:00
|
|
|
|
2009-08-05 22:30:52 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
|
2009-11-29 15:18:39 +08:00
|
|
|
CmdArgs.push_back("-mcode-model");
|
2009-08-05 22:30:52 +08:00
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2009-09-10 06:33:08 +08:00
|
|
|
// Add target specific cpu and features flags.
|
|
|
|
switch(getToolChain().getTriple().getArch()) {
|
|
|
|
default:
|
|
|
|
break;
|
2009-05-06 11:16:41 +08:00
|
|
|
|
2009-09-10 12:57:17 +08:00
|
|
|
case llvm::Triple::arm:
|
|
|
|
case llvm::Triple::thumb:
|
2011-03-18 01:10:06 +08:00
|
|
|
AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
|
2009-09-10 12:57:17 +08:00
|
|
|
break;
|
|
|
|
|
2010-03-02 10:41:08 +08:00
|
|
|
case llvm::Triple::mips:
|
|
|
|
case llvm::Triple::mipsel:
|
|
|
|
AddMIPSTargetArgs(Args, CmdArgs);
|
2010-11-10 01:21:19 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case llvm::Triple::sparc:
|
|
|
|
AddSparcTargetArgs(Args, CmdArgs);
|
2010-03-02 10:41:08 +08:00
|
|
|
break;
|
|
|
|
|
2009-09-10 06:33:08 +08:00
|
|
|
case llvm::Triple::x86:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
AddX86TargetArgs(Args, CmdArgs);
|
|
|
|
break;
|
2009-04-30 02:32:25 +08:00
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-08-12 07:07:47 +08:00
|
|
|
// Pass the linker version in use.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
|
|
|
|
CmdArgs.push_back("-target-linker-version");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2011-02-02 14:43:03 +08:00
|
|
|
// -mno-omit-leaf-frame-pointer is the default on Darwin.
|
2010-07-01 09:31:45 +08:00
|
|
|
if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
|
2011-02-02 14:43:03 +08:00
|
|
|
options::OPT_mno_omit_leaf_frame_pointer,
|
|
|
|
getToolChain().getTriple().getOS() != llvm::Triple::Darwin))
|
2010-07-01 09:31:45 +08:00
|
|
|
CmdArgs.push_back("-momit-leaf-frame-pointer");
|
|
|
|
|
2010-01-08 10:20:44 +08:00
|
|
|
// -fno-math-errno is default.
|
|
|
|
if (Args.hasFlag(options::OPT_fmath_errno,
|
2009-04-30 02:32:25 +08:00
|
|
|
options::OPT_fno_math_errno,
|
2010-01-08 10:20:44 +08:00
|
|
|
false))
|
|
|
|
CmdArgs.push_back("-fmath-errno");
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2010-05-13 02:19:58 +08:00
|
|
|
// Explicitly error on some things we know we don't support and can't just
|
|
|
|
// ignore.
|
|
|
|
types::ID InputType = Inputs[0].getType();
|
2010-09-25 03:39:37 +08:00
|
|
|
if (!Args.hasArg(options::OPT_fallow_unsupported)) {
|
|
|
|
Arg *Unsupported;
|
2011-07-13 03:35:15 +08:00
|
|
|
if ((Unsupported = Args.getLastArg(options::OPT_iframework)))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported)
|
2010-05-13 02:19:58 +08:00
|
|
|
<< Unsupported->getOption().getName();
|
2010-09-25 03:39:37 +08:00
|
|
|
|
|
|
|
if (types::isCXX(InputType) &&
|
|
|
|
getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
|
|
|
|
getToolChain().getTriple().getArch() == llvm::Triple::x86) {
|
2011-08-14 07:48:55 +08:00
|
|
|
if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
|
|
|
|
(Unsupported = Args.getLastArg(options::OPT_mkernel)))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
|
2010-09-25 03:39:37 +08:00
|
|
|
<< Unsupported->getOption().getName();
|
|
|
|
}
|
2010-05-13 02:19:58 +08:00
|
|
|
}
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_v);
|
2010-08-25 06:44:13 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_H);
|
2011-08-03 01:58:04 +08:00
|
|
|
if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
|
2011-02-03 05:11:35 +08:00
|
|
|
CmdArgs.push_back("-header-include-file");
|
|
|
|
CmdArgs.push_back(D.CCPrintHeadersFilename ?
|
|
|
|
D.CCPrintHeadersFilename : "-");
|
|
|
|
}
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_P);
|
2009-09-09 23:08:12 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2011-08-03 01:58:04 +08:00
|
|
|
if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
|
2011-04-08 02:01:20 +08:00
|
|
|
CmdArgs.push_back("-diagnostic-log-file");
|
|
|
|
CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
|
|
|
|
D.CCLogDiagnosticsFilename : "-");
|
|
|
|
}
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
// Special case debug options to only pass -g to clang. This is
|
|
|
|
// wrong.
|
2010-03-07 12:46:18 +08:00
|
|
|
Args.ClaimAllArgs(options::OPT_g_Group);
|
2010-05-13 02:19:55 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_g_Group))
|
|
|
|
if (!A->getOption().matches(options::OPT_g0))
|
|
|
|
CmdArgs.push_back("-g");
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2010-05-07 05:06:04 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
|
|
|
|
|
2010-06-22 08:03:40 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
|
|
|
|
|
2011-04-22 07:44:07 +08:00
|
|
|
if (Args.hasArg(options::OPT_ftest_coverage) ||
|
|
|
|
Args.hasArg(options::OPT_coverage))
|
|
|
|
CmdArgs.push_back("-femit-coverage-notes");
|
|
|
|
if (Args.hasArg(options::OPT_fprofile_arcs) ||
|
|
|
|
Args.hasArg(options::OPT_coverage))
|
|
|
|
CmdArgs.push_back("-femit-coverage-data");
|
|
|
|
|
2011-05-05 04:46:58 +08:00
|
|
|
if (C.getArgs().hasArg(options::OPT_c) ||
|
|
|
|
C.getArgs().hasArg(options::OPT_S)) {
|
|
|
|
if (Output.isFilename()) {
|
2011-05-05 08:08:20 +08:00
|
|
|
CmdArgs.push_back("-coverage-file");
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
|
2011-05-05 04:46:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_nostdinc);
|
2010-03-25 04:13:48 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
|
2009-10-26 21:36:57 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2009-12-15 09:02:52 +08:00
|
|
|
// Pass the path to compiler resource files.
|
|
|
|
CmdArgs.push_back("-resource-dir");
|
2010-01-20 10:35:16 +08:00
|
|
|
CmdArgs.push_back(D.ResourceDir.c_str());
|
2009-04-08 05:42:00 +08:00
|
|
|
|
2010-11-04 06:45:23 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_working_directory);
|
|
|
|
|
2011-06-16 07:25:17 +08:00
|
|
|
if (!Args.hasArg(options::OPT_fno_objc_arc)) {
|
2011-07-07 12:00:39 +08:00
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
|
2011-07-10 04:00:58 +08:00
|
|
|
options::OPT_ccc_arcmt_modify,
|
|
|
|
options::OPT_ccc_arcmt_migrate)) {
|
2011-06-16 07:25:17 +08:00
|
|
|
switch (A->getOption().getID()) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("missed a case");
|
2011-07-07 12:00:39 +08:00
|
|
|
case options::OPT_ccc_arcmt_check:
|
2011-06-16 07:25:17 +08:00
|
|
|
CmdArgs.push_back("-arcmt-check");
|
|
|
|
break;
|
2011-07-07 12:00:39 +08:00
|
|
|
case options::OPT_ccc_arcmt_modify:
|
2011-06-16 07:25:17 +08:00
|
|
|
CmdArgs.push_back("-arcmt-modify");
|
|
|
|
break;
|
2011-07-10 04:00:58 +08:00
|
|
|
case options::OPT_ccc_arcmt_migrate:
|
|
|
|
CmdArgs.push_back("-arcmt-migrate");
|
|
|
|
CmdArgs.push_back("-arcmt-migrate-directory");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
2011-07-20 01:20:03 +08:00
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
|
2011-07-10 04:00:58 +08:00
|
|
|
break;
|
2011-06-16 07:25:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-08-19 08:30:14 +08:00
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
// Add preprocessing options like -I, -D, etc. if we are using the
|
|
|
|
// preprocessor.
|
|
|
|
//
|
|
|
|
// FIXME: Support -fpreprocessed
|
|
|
|
if (types::getPreprocessedType(InputType) != types::TY_INVALID)
|
2009-04-18 08:34:01 +08:00
|
|
|
AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2011-07-22 07:40:37 +08:00
|
|
|
// Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
|
|
|
|
// that "The compiler can only warn and ignore the option if not recognized".
|
|
|
|
// When building with ccache, it will pass -D options to clang even on
|
|
|
|
// preprocessed inputs and configure concludes that -fPIC is not supported.
|
|
|
|
Args.ClaimAllArgs(options::OPT_D);
|
|
|
|
|
2009-09-17 14:53:36 +08:00
|
|
|
// Manually translate -O to -O2 and -O4 to -O3; let clang reject
|
2009-03-25 04:17:30 +08:00
|
|
|
// others.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
|
2009-11-19 11:26:40 +08:00
|
|
|
if (A->getOption().matches(options::OPT_O4))
|
2009-03-25 04:17:30 +08:00
|
|
|
CmdArgs.push_back("-O3");
|
2010-05-27 14:51:08 +08:00
|
|
|
else if (A->getOption().matches(options::OPT_O) &&
|
|
|
|
A->getValue(Args)[0] == '\0')
|
2009-09-17 14:53:36 +08:00
|
|
|
CmdArgs.push_back("-O2");
|
2009-03-18 18:01:51 +08:00
|
|
|
else
|
2009-03-19 07:39:35 +08:00
|
|
|
A->render(Args, CmdArgs);
|
2009-03-18 18:01:51 +08:00
|
|
|
}
|
|
|
|
|
2009-10-29 10:24:45 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_pedantic);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_w);
|
2009-04-08 06:13:21 +08:00
|
|
|
|
|
|
|
// Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
|
|
|
|
// (-ansi is equivalent to -std=c89).
|
|
|
|
//
|
|
|
|
// If a std is supplied, only add -trigraphs if it follows the
|
|
|
|
// option.
|
|
|
|
if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
|
|
|
|
if (Std->getOption().matches(options::OPT_ansi))
|
2009-10-16 22:28:06 +08:00
|
|
|
if (types::isCXX(InputType))
|
2009-11-04 14:24:38 +08:00
|
|
|
CmdArgs.push_back("-std=c++98");
|
2009-10-16 22:28:06 +08:00
|
|
|
else
|
2009-11-04 14:24:38 +08:00
|
|
|
CmdArgs.push_back("-std=c89");
|
2009-04-08 06:13:21 +08:00
|
|
|
else
|
|
|
|
Std->render(Args, CmdArgs);
|
|
|
|
|
2010-06-15 05:23:08 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
|
|
|
|
options::OPT_trigraphs))
|
|
|
|
if (A != Std)
|
2009-04-08 06:13:21 +08:00
|
|
|
A->render(Args, CmdArgs);
|
2009-04-26 09:10:38 +08:00
|
|
|
} else {
|
|
|
|
// Honor -std-default.
|
2010-01-30 05:03:02 +08:00
|
|
|
//
|
|
|
|
// FIXME: Clang doesn't correctly handle -std= when the input language
|
|
|
|
// doesn't match. For the time being just ignore this for C++ inputs;
|
|
|
|
// eventually we want to do all the standard defaulting here instead of
|
|
|
|
// splitting it between the driver and clang -cc1.
|
|
|
|
if (!types::isCXX(InputType))
|
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
|
|
|
|
"-std=", /*Joined=*/true);
|
2009-04-08 06:13:21 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
|
2009-04-26 09:10:38 +08:00
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2011-04-23 14:30:43 +08:00
|
|
|
// Map the bizarre '-Wwrite-strings' flag to a more sensible
|
|
|
|
// '-fconst-strings'; this better indicates its actual behavior.
|
|
|
|
if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
|
|
|
|
false)) {
|
|
|
|
// For perfect compatibility with GCC, we do this even in the presence of
|
|
|
|
// '-w'. This flag names something other than a warning for GCC.
|
|
|
|
CmdArgs.push_back("-fconst-strings");
|
|
|
|
}
|
|
|
|
|
2011-04-23 17:27:53 +08:00
|
|
|
// GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
|
2011-04-24 03:48:40 +08:00
|
|
|
// during C++ compilation, which it is by default. GCC keeps this define even
|
|
|
|
// in the presence of '-w', match this behavior bug-for-bug.
|
|
|
|
if (types::isCXX(InputType) &&
|
|
|
|
Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
|
|
|
|
true)) {
|
|
|
|
CmdArgs.push_back("-fdeprecated-macro");
|
2011-04-23 17:27:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-22 10:21:53 +08:00
|
|
|
// Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
|
|
|
|
if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
|
|
|
|
if (Asm->getOption().matches(options::OPT_fasm))
|
|
|
|
CmdArgs.push_back("-fgnu-keywords");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-fno-gnu-keywords");
|
|
|
|
}
|
|
|
|
|
2011-05-03 01:43:32 +08:00
|
|
|
if (ShouldDisableCFI(Args, getToolChain()))
|
|
|
|
CmdArgs.push_back("-fno-dwarf2-cfi-asm");
|
2011-05-01 02:35:43 +08:00
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
|
|
|
|
CmdArgs.push_back("-ftemplate-depth");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
2009-03-18 16:07:30 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 08:20:36 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
|
|
|
|
options::OPT_Wlarge_by_value_copy_def)) {
|
|
|
|
CmdArgs.push_back("-Wlarge-by-value-copy");
|
2010-11-18 07:11:54 +08:00
|
|
|
if (A->getNumValues())
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
else
|
2010-11-18 08:20:36 +08:00
|
|
|
CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
|
2010-11-18 07:11:54 +08:00
|
|
|
}
|
|
|
|
|
2009-11-19 12:00:53 +08:00
|
|
|
if (Args.hasArg(options::OPT__relocatable_pch))
|
2009-11-21 06:21:36 +08:00
|
|
|
CmdArgs.push_back("-relocatable-pch");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-04 14:24:38 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
|
|
|
|
CmdArgs.push_back("-fconstant-string-class");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
2009-09-01 00:41:57 +08:00
|
|
|
|
2010-01-10 05:54:33 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
|
|
|
|
CmdArgs.push_back("-ftabstop");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2010-04-08 04:49:23 +08:00
|
|
|
CmdArgs.push_back("-ferror-limit");
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("19");
|
2010-04-20 15:18:24 +08:00
|
|
|
|
2010-05-06 12:55:18 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
|
|
|
|
CmdArgs.push_back("-fmacro-backtrace-limit");
|
2010-05-05 01:13:42 +08:00
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
2010-05-06 12:55:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
|
|
|
|
CmdArgs.push_back("-ftemplate-backtrace-limit");
|
2010-04-20 15:18:24 +08:00
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
2010-05-06 12:55:18 +08:00
|
|
|
}
|
|
|
|
|
2009-11-04 14:24:47 +08:00
|
|
|
// Pass -fmessage-length=.
|
2009-11-30 16:40:54 +08:00
|
|
|
CmdArgs.push_back("-fmessage-length");
|
2009-11-04 14:24:47 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
|
2009-11-30 16:40:54 +08:00
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
2009-11-04 14:24:47 +08:00
|
|
|
} else {
|
|
|
|
// If -fmessage-length=N was not specified, determine whether this is a
|
|
|
|
// terminal and, if so, implicitly define -fmessage-length appropriately.
|
|
|
|
unsigned N = llvm::sys::Process::StandardErrColumns();
|
2011-07-23 18:55:15 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(Twine(N)));
|
2009-11-04 14:24:47 +08:00
|
|
|
}
|
|
|
|
|
2009-12-04 02:42:11 +08:00
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
|
|
|
|
CmdArgs.push_back("-fvisibility");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2010-06-16 01:05:35 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2010-03-20 12:52:14 +08:00
|
|
|
// -fhosted is default.
|
|
|
|
if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
|
|
|
|
options::OPT_fhosted,
|
|
|
|
false))
|
|
|
|
CmdArgs.push_back("-ffreestanding");
|
|
|
|
|
2009-12-04 02:42:11 +08:00
|
|
|
// Forward -f (flag) options which we can pass directly.
|
2009-12-12 09:27:46 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
|
2009-04-08 05:51:40 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
|
2010-10-01 03:05:55 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
|
2011-03-02 02:49:30 +08:00
|
|
|
if (getToolChain().SupportsProfiling())
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_pg);
|
2010-03-17 00:57:46 +08:00
|
|
|
|
|
|
|
// -flax-vector-conversions is default.
|
|
|
|
if (!Args.hasFlag(options::OPT_flax_vector_conversions,
|
|
|
|
options::OPT_fno_lax_vector_conversions))
|
|
|
|
CmdArgs.push_back("-fno-lax-vector-conversions");
|
|
|
|
|
2011-01-07 09:05:02 +08:00
|
|
|
if (Args.getLastArg(options::OPT_fapple_kext))
|
|
|
|
CmdArgs.push_back("-fapple-kext");
|
|
|
|
|
2009-05-23 04:17:16 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
|
2009-04-21 13:34:31 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
|
2010-08-20 04:24:43 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
|
2009-04-08 05:51:40 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
|
2010-09-18 02:29:54 +08:00
|
|
|
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
|
|
|
|
CmdArgs.push_back("-ftrapv-handler");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2011-04-09 05:37:45 +08:00
|
|
|
// Forward -ftrap_function= options to the backend.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef FuncName = A->getValue(Args);
|
2011-04-09 05:37:45 +08:00
|
|
|
CmdArgs.push_back("-backend-option");
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName));
|
|
|
|
}
|
|
|
|
|
2011-03-27 08:04:55 +08:00
|
|
|
// -fno-strict-overflow implies -fwrapv if it isn't disabled, but
|
|
|
|
// -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
|
|
|
|
options::OPT_fno_wrapv)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fwrapv))
|
|
|
|
CmdArgs.push_back("-fwrapv");
|
|
|
|
} else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
|
|
|
|
options::OPT_fno_strict_overflow)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fno_strict_overflow))
|
|
|
|
CmdArgs.push_back("-fwrapv");
|
|
|
|
}
|
2009-04-08 05:51:40 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
|
2010-08-08 07:08:14 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2009-09-03 12:54:28 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_pthread);
|
|
|
|
|
2009-11-17 16:07:36 +08:00
|
|
|
// -stack-protector=0 is default.
|
|
|
|
unsigned StackProtectorLevel = 0;
|
2009-06-28 15:36:13 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
|
|
|
|
options::OPT_fstack_protector_all,
|
|
|
|
options::OPT_fstack_protector)) {
|
2009-11-17 16:07:36 +08:00
|
|
|
if (A->getOption().matches(options::OPT_fstack_protector))
|
|
|
|
StackProtectorLevel = 1;
|
|
|
|
else if (A->getOption().matches(options::OPT_fstack_protector_all))
|
|
|
|
StackProtectorLevel = 2;
|
2011-08-23 15:38:27 +08:00
|
|
|
} else {
|
|
|
|
StackProtectorLevel =
|
|
|
|
getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
|
|
|
|
}
|
2009-11-17 16:07:36 +08:00
|
|
|
if (StackProtectorLevel) {
|
|
|
|
CmdArgs.push_back("-stack-protector");
|
2011-07-23 18:55:15 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
|
2009-06-28 15:36:13 +08:00
|
|
|
}
|
|
|
|
|
2011-05-03 05:18:22 +08:00
|
|
|
// Translate -mstackrealign
|
|
|
|
if (Args.hasArg(options::OPT_mstackrealign)) {
|
|
|
|
CmdArgs.push_back("-backend-option");
|
|
|
|
CmdArgs.push_back("-force-align-stack");
|
|
|
|
}
|
2011-08-19 08:30:14 +08:00
|
|
|
|
2009-04-08 05:16:11 +08:00
|
|
|
// Forward -f options with positive and negative forms; we translate
|
|
|
|
// these by hand.
|
|
|
|
|
2011-01-07 09:05:02 +08:00
|
|
|
if (Args.hasArg(options::OPT_mkernel)) {
|
2011-02-05 01:24:47 +08:00
|
|
|
if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
|
2011-01-07 09:05:02 +08:00
|
|
|
CmdArgs.push_back("-fapple-kext");
|
|
|
|
if (!Args.hasArg(options::OPT_fbuiltin))
|
|
|
|
CmdArgs.push_back("-fno-builtin");
|
|
|
|
}
|
2009-11-17 16:07:36 +08:00
|
|
|
// -fbuiltin is default.
|
2011-01-07 09:05:02 +08:00
|
|
|
else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
|
2009-11-19 12:55:23 +08:00
|
|
|
CmdArgs.push_back("-fno-builtin");
|
2009-04-08 05:16:11 +08:00
|
|
|
|
2009-12-17 00:59:22 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
|
|
|
|
options::OPT_fno_assume_sane_operator_new))
|
|
|
|
CmdArgs.push_back("-fno-assume-sane-operator-new");
|
|
|
|
|
2009-11-17 16:07:36 +08:00
|
|
|
// -fblocks=0 is default.
|
|
|
|
if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
|
2011-03-01 01:11:43 +08:00
|
|
|
getToolChain().IsBlocksDefault()) ||
|
|
|
|
(Args.hasArg(options::OPT_fgnu_runtime) &&
|
|
|
|
Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
|
|
|
|
!Args.hasArg(options::OPT_fno_blocks))) {
|
2009-11-17 16:07:36 +08:00
|
|
|
CmdArgs.push_back("-fblocks");
|
2009-11-18 03:33:30 +08:00
|
|
|
}
|
2009-04-08 05:16:11 +08:00
|
|
|
|
2010-04-10 03:12:06 +08:00
|
|
|
// -faccess-control is default.
|
2010-04-10 03:03:51 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fno_access_control,
|
|
|
|
options::OPT_faccess_control,
|
2010-04-10 03:12:06 +08:00
|
|
|
false))
|
2010-04-10 03:03:51 +08:00
|
|
|
CmdArgs.push_back("-fno-access-control");
|
2010-03-17 09:32:13 +08:00
|
|
|
|
2010-11-21 08:09:52 +08:00
|
|
|
// -felide-constructors is the default.
|
|
|
|
if (Args.hasFlag(options::OPT_fno_elide_constructors,
|
|
|
|
options::OPT_felide_constructors,
|
|
|
|
false))
|
|
|
|
CmdArgs.push_back("-fno-elide-constructors");
|
|
|
|
|
2009-11-17 15:06:20 +08:00
|
|
|
// -frtti is default.
|
2010-03-20 12:52:14 +08:00
|
|
|
if (KernelOrKext ||
|
|
|
|
!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
|
2009-11-19 12:55:23 +08:00
|
|
|
CmdArgs.push_back("-fno-rtti");
|
2009-08-01 07:15:31 +08:00
|
|
|
|
2010-10-08 08:25:19 +08:00
|
|
|
// -fshort-enums=0 is default.
|
|
|
|
// FIXME: Are there targers where -fshort-enums is on by default ?
|
|
|
|
if (Args.hasFlag(options::OPT_fshort_enums,
|
|
|
|
options::OPT_fno_short_enums, false))
|
|
|
|
CmdArgs.push_back("-fshort-enums");
|
|
|
|
|
2009-11-17 14:37:03 +08:00
|
|
|
// -fsigned-char is default.
|
2009-11-25 18:14:30 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
|
2009-11-17 14:37:03 +08:00
|
|
|
isSignedCharDefault(getToolChain().getTriple())))
|
2009-11-29 10:39:08 +08:00
|
|
|
CmdArgs.push_back("-fno-signed-char");
|
2009-06-05 15:21:14 +08:00
|
|
|
|
2010-02-07 07:23:06 +08:00
|
|
|
// -fthreadsafe-static is default.
|
2010-10-21 11:16:25 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
|
2010-02-07 07:23:06 +08:00
|
|
|
options::OPT_fno_threadsafe_statics))
|
|
|
|
CmdArgs.push_back("-fno-threadsafe-statics");
|
|
|
|
|
2010-03-20 12:15:41 +08:00
|
|
|
// -fuse-cxa-atexit is default.
|
2010-09-11 19:17:06 +08:00
|
|
|
if (KernelOrKext ||
|
|
|
|
!Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
|
2010-10-10 09:53:03 +08:00
|
|
|
getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
|
2011-02-17 16:51:38 +08:00
|
|
|
getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
|
2010-03-20 12:15:41 +08:00
|
|
|
CmdArgs.push_back("-fno-use-cxa-atexit");
|
|
|
|
|
2009-11-17 15:06:20 +08:00
|
|
|
// -fms-extensions=0 is default.
|
2009-11-25 18:14:30 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
|
2009-11-17 15:06:20 +08:00
|
|
|
getToolChain().getTriple().getOS() == llvm::Triple::Win32))
|
|
|
|
CmdArgs.push_back("-fms-extensions");
|
|
|
|
|
2010-10-21 13:21:48 +08:00
|
|
|
// -fmsc-version=1300 is default.
|
|
|
|
if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
|
|
|
|
getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
|
|
|
|
Args.hasArg(options::OPT_fmsc_version)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
|
2010-10-21 13:21:48 +08:00
|
|
|
if (msc_ver.empty())
|
|
|
|
CmdArgs.push_back("-fmsc-version=1300");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-03 07:59:25 +08:00
|
|
|
// -fborland-extensions=0 is default.
|
|
|
|
if (Args.hasFlag(options::OPT_fborland_extensions,
|
|
|
|
options::OPT_fno_borland_extensions, false))
|
|
|
|
CmdArgs.push_back("-fborland-extensions");
|
|
|
|
|
2011-09-02 00:38:08 +08:00
|
|
|
// -fno-delayed-template-parsing is default, except for Windows where MSVC STL
|
|
|
|
// needs it.
|
2011-04-23 06:18:13 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
|
|
|
|
options::OPT_fno_delayed_template_parsing,
|
2011-09-02 00:38:08 +08:00
|
|
|
getToolChain().getTriple().getOS() == llvm::Triple::Win32))
|
2011-08-26 08:22:34 +08:00
|
|
|
CmdArgs.push_back("-fdelayed-template-parsing");
|
2011-04-23 06:18:13 +08:00
|
|
|
|
2010-04-18 04:17:31 +08:00
|
|
|
// -fgnu-keywords default varies depending on language; only pass if
|
|
|
|
// specified.
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
|
2010-04-25 01:56:39 +08:00
|
|
|
options::OPT_fno_gnu_keywords))
|
|
|
|
A->render(Args, CmdArgs);
|
2010-04-18 04:17:31 +08:00
|
|
|
|
2011-06-03 01:30:53 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fgnu89_inline,
|
|
|
|
options::OPT_fno_gnu89_inline,
|
|
|
|
false))
|
2011-06-03 00:13:27 +08:00
|
|
|
CmdArgs.push_back("-fgnu89-inline");
|
|
|
|
|
2009-11-17 16:07:36 +08:00
|
|
|
// -fobjc-nonfragile-abi=0 is default.
|
2011-07-06 08:26:06 +08:00
|
|
|
ObjCRuntime objCRuntime;
|
2011-06-22 08:53:57 +08:00
|
|
|
unsigned objcABIVersion = 0;
|
2009-11-17 16:07:36 +08:00
|
|
|
if (types::isObjC(InputType)) {
|
2011-07-06 08:26:06 +08:00
|
|
|
bool NeXTRuntimeIsDefault
|
|
|
|
= (IsRewriter || getToolChain().getTriple().isOSDarwin());
|
|
|
|
if (Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
|
2011-07-06 10:36:30 +08:00
|
|
|
NeXTRuntimeIsDefault)) {
|
2011-07-06 08:26:06 +08:00
|
|
|
objCRuntime.setKind(ObjCRuntime::NeXT);
|
2011-07-06 10:36:30 +08:00
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-fgnu-runtime");
|
2011-07-06 08:26:06 +08:00
|
|
|
objCRuntime.setKind(ObjCRuntime::GNU);
|
2011-07-06 10:36:30 +08:00
|
|
|
}
|
2011-07-06 08:26:06 +08:00
|
|
|
getToolChain().configureObjCRuntime(objCRuntime);
|
|
|
|
if (objCRuntime.HasARC)
|
|
|
|
CmdArgs.push_back("-fobjc-runtime-has-arc");
|
|
|
|
if (objCRuntime.HasWeak)
|
|
|
|
CmdArgs.push_back("-fobjc-runtime-has-weak");
|
2011-07-06 09:22:26 +08:00
|
|
|
if (objCRuntime.HasTerminate)
|
|
|
|
CmdArgs.push_back("-fobjc-runtime-has-terminate");
|
2011-07-06 08:26:06 +08:00
|
|
|
|
2010-09-21 02:19:55 +08:00
|
|
|
// Compute the Objective-C ABI "version" to use. Version numbers are
|
|
|
|
// slightly confusing for historical reasons:
|
|
|
|
// 1 - Traditional "fragile" ABI
|
|
|
|
// 2 - Non-fragile ABI, version 1
|
|
|
|
// 3 - Non-fragile ABI, version 2
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 1;
|
2010-09-21 02:19:55 +08:00
|
|
|
// If -fobjc-abi-version= is present, use that to set the version.
|
2010-04-29 07:25:24 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef(A->getValue(Args)) == "1")
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 1;
|
2011-07-23 18:55:15 +08:00
|
|
|
else if (StringRef(A->getValue(Args)) == "2")
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 2;
|
2011-07-23 18:55:15 +08:00
|
|
|
else if (StringRef(A->getValue(Args)) == "3")
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 3;
|
2010-04-29 07:25:24 +08:00
|
|
|
else
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
|
2010-09-21 02:19:55 +08:00
|
|
|
} else {
|
|
|
|
// Otherwise, determine if we are using the non-fragile ABI.
|
|
|
|
if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
|
|
|
|
options::OPT_fno_objc_nonfragile_abi,
|
|
|
|
getToolChain().IsObjCNonFragileABIDefault())) {
|
|
|
|
// Determine the non-fragile ABI version to use.
|
2010-11-12 00:08:59 +08:00
|
|
|
#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
|
|
|
|
unsigned NonFragileABIVersion = 1;
|
|
|
|
#else
|
2010-09-21 02:19:55 +08:00
|
|
|
unsigned NonFragileABIVersion = 2;
|
2010-11-12 00:08:59 +08:00
|
|
|
#endif
|
2010-09-21 02:19:55 +08:00
|
|
|
|
|
|
|
if (Arg *A = Args.getLastArg(
|
|
|
|
options::OPT_fobjc_nonfragile_abi_version_EQ)) {
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef(A->getValue(Args)) == "1")
|
2010-09-21 02:19:55 +08:00
|
|
|
NonFragileABIVersion = 1;
|
2011-07-23 18:55:15 +08:00
|
|
|
else if (StringRef(A->getValue(Args)) == "2")
|
2010-09-21 02:19:55 +08:00
|
|
|
NonFragileABIVersion = 2;
|
|
|
|
else
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported)
|
2010-09-21 02:19:55 +08:00
|
|
|
<< A->getAsString(Args);
|
|
|
|
}
|
|
|
|
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 1 + NonFragileABIVersion;
|
2010-09-21 02:19:55 +08:00
|
|
|
} else {
|
2011-06-22 08:53:57 +08:00
|
|
|
objcABIVersion = 1;
|
2010-09-21 02:19:55 +08:00
|
|
|
}
|
2010-04-29 07:25:24 +08:00
|
|
|
}
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2011-06-22 08:53:57 +08:00
|
|
|
if (objcABIVersion == 2 || objcABIVersion == 3) {
|
2011-01-05 04:05:20 +08:00
|
|
|
CmdArgs.push_back("-fobjc-nonfragile-abi");
|
2010-04-25 01:56:46 +08:00
|
|
|
|
|
|
|
// -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
|
|
|
|
// legacy is the default.
|
|
|
|
if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
|
|
|
|
options::OPT_fno_objc_legacy_dispatch,
|
|
|
|
getToolChain().IsObjCLegacyDispatchDefault())) {
|
|
|
|
if (getToolChain().UseObjCMixedDispatch())
|
|
|
|
CmdArgs.push_back("-fobjc-dispatch-method=mixed");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
|
|
|
|
}
|
2010-02-02 05:07:25 +08:00
|
|
|
}
|
2011-02-17 16:50:50 +08:00
|
|
|
|
2010-12-24 05:35:43 +08:00
|
|
|
// -fobjc-default-synthesize-properties=0 is default.
|
|
|
|
if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
|
|
|
|
options::OPT_fno_objc_default_synthesize_properties,
|
|
|
|
getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
|
|
|
|
CmdArgs.push_back("-fobjc-default-synthesize-properties");
|
|
|
|
}
|
2009-11-17 16:07:36 +08:00
|
|
|
}
|
|
|
|
|
2011-07-06 08:26:06 +08:00
|
|
|
// Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
|
|
|
|
// NOTE: This logic is duplicated in ToolChains.cpp.
|
|
|
|
bool ARC = isObjCAutoRefCount(Args);
|
|
|
|
if (ARC) {
|
|
|
|
CmdArgs.push_back("-fobjc-arc");
|
|
|
|
|
|
|
|
// Allow the user to enable full exceptions code emission.
|
|
|
|
// We define off for Objective-CC, on for Objective-C++.
|
|
|
|
if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
|
|
|
|
options::OPT_fno_objc_arc_exceptions,
|
|
|
|
/*default*/ types::isCXX(InputType)))
|
|
|
|
CmdArgs.push_back("-fobjc-arc-exceptions");
|
|
|
|
}
|
|
|
|
|
|
|
|
// -fobjc-infer-related-result-type is the default, except in the Objective-C
|
|
|
|
// rewriter.
|
|
|
|
if (IsRewriter)
|
|
|
|
CmdArgs.push_back("-fno-objc-infer-related-result-type");
|
2011-08-19 08:30:14 +08:00
|
|
|
|
2011-07-06 08:26:06 +08:00
|
|
|
// Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
|
|
|
|
// takes precedence.
|
|
|
|
const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
|
|
|
|
if (!GCArg)
|
|
|
|
GCArg = Args.getLastArg(options::OPT_fobjc_gc);
|
|
|
|
if (GCArg) {
|
|
|
|
if (ARC) {
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_objc_gc_arr)
|
2011-07-06 08:26:06 +08:00
|
|
|
<< GCArg->getAsString(Args);
|
|
|
|
} else if (getToolChain().SupportsObjCGC()) {
|
|
|
|
GCArg->render(Args, CmdArgs);
|
|
|
|
} else {
|
|
|
|
// FIXME: We should move this to a hard error.
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_objc_gc_unsupported)
|
2011-07-06 08:26:06 +08:00
|
|
|
<< GCArg->getAsString(Args);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-22 08:53:57 +08:00
|
|
|
// Add exception args.
|
|
|
|
addExceptionArgs(Args, InputType, getToolChain().getTriple(),
|
|
|
|
KernelOrKext, IsRewriter, objcABIVersion, CmdArgs);
|
|
|
|
|
|
|
|
if (getToolChain().UseSjLjExceptions())
|
|
|
|
CmdArgs.push_back("-fsjlj-exceptions");
|
|
|
|
|
|
|
|
// C++ "sane" operator new.
|
2010-02-02 05:07:25 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
|
|
|
|
options::OPT_fno_assume_sane_operator_new))
|
|
|
|
CmdArgs.push_back("-fno-assume-sane-operator-new");
|
|
|
|
|
2010-04-27 23:34:57 +08:00
|
|
|
// -fconstant-cfstrings is default, and may be subject to argument translation
|
|
|
|
// on Darwin.
|
|
|
|
if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
|
|
|
|
options::OPT_fno_constant_cfstrings) ||
|
|
|
|
!Args.hasFlag(options::OPT_mconstant_cfstrings,
|
|
|
|
options::OPT_mno_constant_cfstrings))
|
|
|
|
CmdArgs.push_back("-fno-constant-cfstrings");
|
|
|
|
|
2009-11-06 04:14:16 +08:00
|
|
|
// -fshort-wchar default varies depending on platform; only
|
|
|
|
// pass if specified.
|
2010-04-27 23:35:03 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
|
|
|
|
A->render(Args, CmdArgs);
|
2009-11-06 04:14:16 +08:00
|
|
|
|
2009-10-29 10:39:57 +08:00
|
|
|
// -fno-pascal-strings is default, only pass non-default. If the tool chain
|
|
|
|
// happened to translate to -mpascal-strings, we want to back translate here.
|
2009-04-08 07:51:44 +08:00
|
|
|
//
|
|
|
|
// FIXME: This is gross; that translation should be pulled from the
|
|
|
|
// tool chain.
|
2009-04-09 07:54:23 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fpascal_strings,
|
2009-04-08 07:51:44 +08:00
|
|
|
options::OPT_fno_pascal_strings,
|
|
|
|
false) ||
|
|
|
|
Args.hasFlag(options::OPT_mpascal_strings,
|
|
|
|
options::OPT_mno_pascal_strings,
|
|
|
|
false))
|
2009-04-08 05:16:11 +08:00
|
|
|
CmdArgs.push_back("-fpascal-strings");
|
2011-02-17 16:50:50 +08:00
|
|
|
|
2011-01-07 09:05:02 +08:00
|
|
|
if (Args.hasArg(options::OPT_mkernel) ||
|
|
|
|
Args.hasArg(options::OPT_fapple_kext)) {
|
|
|
|
if (!Args.hasArg(options::OPT_fcommon))
|
|
|
|
CmdArgs.push_back("-fno-common");
|
|
|
|
}
|
2009-04-08 05:16:11 +08:00
|
|
|
// -fcommon is default, only pass non-default.
|
2011-01-07 09:05:02 +08:00
|
|
|
else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
|
2009-04-08 05:16:11 +08:00
|
|
|
CmdArgs.push_back("-fno-common");
|
|
|
|
|
2009-04-15 10:37:43 +08:00
|
|
|
// -fsigned-bitfields is default, and clang doesn't yet support
|
2010-10-16 06:30:42 +08:00
|
|
|
// -funsigned-bitfields.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fsigned_bitfields,
|
2009-04-15 10:37:43 +08:00
|
|
|
options::OPT_funsigned_bitfields))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_clang_unsupported)
|
2009-04-15 10:37:43 +08:00
|
|
|
<< Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
|
|
|
|
|
2010-10-16 06:30:42 +08:00
|
|
|
// -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
|
|
|
|
if (!Args.hasFlag(options::OPT_ffor_scope,
|
|
|
|
options::OPT_fno_for_scope))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported)
|
2010-10-16 06:30:42 +08:00
|
|
|
<< Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
|
|
|
|
|
2010-06-08 12:56:20 +08:00
|
|
|
// -fcaret-diagnostics is default.
|
|
|
|
if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
|
|
|
|
options::OPT_fno_caret_diagnostics, true))
|
|
|
|
CmdArgs.push_back("-fno-caret-diagnostics");
|
|
|
|
|
2009-04-20 05:09:34 +08:00
|
|
|
// -fdiagnostics-fixit-info is default, only pass non-default.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
|
2009-04-20 05:09:34 +08:00
|
|
|
options::OPT_fno_diagnostics_fixit_info))
|
|
|
|
CmdArgs.push_back("-fno-diagnostics-fixit-info");
|
2011-08-19 08:30:14 +08:00
|
|
|
|
2011-04-16 06:04:17 +08:00
|
|
|
// Enable -fdiagnostics-show-name by default.
|
|
|
|
if (Args.hasFlag(options::OPT_fdiagnostics_show_name,
|
|
|
|
options::OPT_fno_diagnostics_show_name, false))
|
|
|
|
CmdArgs.push_back("-fdiagnostics-show-name");
|
2009-04-20 05:09:34 +08:00
|
|
|
|
2009-04-16 14:32:38 +08:00
|
|
|
// Enable -fdiagnostics-show-option by default.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
|
2009-04-16 14:32:38 +08:00
|
|
|
options::OPT_fno_diagnostics_show_option))
|
|
|
|
CmdArgs.push_back("-fdiagnostics-show-option");
|
2009-11-04 14:24:57 +08:00
|
|
|
|
2010-05-05 05:55:25 +08:00
|
|
|
if (const Arg *A =
|
|
|
|
Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
|
|
|
|
CmdArgs.push_back("-fdiagnostics-show-category");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
2010-08-25 00:47:49 +08:00
|
|
|
|
2011-05-22 01:07:29 +08:00
|
|
|
if (const Arg *A =
|
|
|
|
Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
|
|
|
|
CmdArgs.push_back("-fdiagnostics-format");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
}
|
|
|
|
|
2011-03-27 09:50:55 +08:00
|
|
|
if (Arg *A = Args.getLastArg(
|
|
|
|
options::OPT_fdiagnostics_show_note_include_stack,
|
|
|
|
options::OPT_fno_diagnostics_show_note_include_stack)) {
|
|
|
|
if (A->getOption().matches(
|
|
|
|
options::OPT_fdiagnostics_show_note_include_stack))
|
|
|
|
CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
|
|
|
|
}
|
|
|
|
|
2009-11-04 14:24:57 +08:00
|
|
|
// Color diagnostics are the default, unless the terminal doesn't support
|
|
|
|
// them.
|
|
|
|
if (Args.hasFlag(options::OPT_fcolor_diagnostics,
|
2010-09-23 20:56:06 +08:00
|
|
|
options::OPT_fno_color_diagnostics,
|
|
|
|
llvm::sys::Process::StandardErrHasColors()))
|
2009-11-04 14:24:57 +08:00
|
|
|
CmdArgs.push_back("-fcolor-diagnostics");
|
|
|
|
|
2009-06-09 05:13:54 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fshow_source_location,
|
|
|
|
options::OPT_fno_show_source_location))
|
|
|
|
CmdArgs.push_back("-fno-show-source-location");
|
2009-04-16 14:32:38 +08:00
|
|
|
|
2011-05-22 01:07:29 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fshow_column,
|
|
|
|
options::OPT_fno_show_column,
|
|
|
|
true))
|
|
|
|
CmdArgs.push_back("-fno-show-column");
|
|
|
|
|
2010-07-10 01:35:33 +08:00
|
|
|
if (!Args.hasFlag(options::OPT_fspell_checking,
|
|
|
|
options::OPT_fno_spell_checking))
|
|
|
|
CmdArgs.push_back("-fno-spell-checking");
|
2010-08-25 00:47:49 +08:00
|
|
|
|
2010-10-19 06:49:46 +08:00
|
|
|
|
2010-11-03 03:42:04 +08:00
|
|
|
// Silently ignore -fasm-blocks for now.
|
|
|
|
(void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
|
|
|
|
false);
|
2010-10-19 06:49:46 +08:00
|
|
|
|
2010-06-11 13:57:47 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
|
|
|
|
A->render(Args, CmdArgs);
|
|
|
|
|
2009-04-20 05:20:32 +08:00
|
|
|
// -fdollars-in-identifiers default varies depending on platform and
|
|
|
|
// language; only pass if specified.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
|
2009-04-20 05:20:32 +08:00
|
|
|
options::OPT_fno_dollars_in_identifiers)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
|
2009-12-17 04:10:18 +08:00
|
|
|
CmdArgs.push_back("-fdollars-in-identifiers");
|
2009-04-20 05:20:32 +08:00
|
|
|
else
|
2009-12-17 04:10:18 +08:00
|
|
|
CmdArgs.push_back("-fno-dollars-in-identifiers");
|
2009-04-20 05:20:32 +08:00
|
|
|
}
|
|
|
|
|
2009-05-23 03:02:20 +08:00
|
|
|
// -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
|
|
|
|
// practical purposes.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
|
2009-05-23 03:02:20 +08:00
|
|
|
options::OPT_fno_unit_at_a_time)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
|
2009-05-23 03:02:20 +08:00
|
|
|
}
|
2009-07-15 05:58:17 +08:00
|
|
|
|
2009-09-10 11:37:02 +08:00
|
|
|
// Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
|
2009-09-10 12:57:27 +08:00
|
|
|
//
|
2009-12-12 07:00:49 +08:00
|
|
|
// FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
|
2009-09-10 12:57:27 +08:00
|
|
|
#if 0
|
2009-09-10 11:37:02 +08:00
|
|
|
if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin &&
|
|
|
|
(getToolChain().getTriple().getArch() == llvm::Triple::arm ||
|
|
|
|
getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
|
|
|
|
if (!Args.hasArg(options::OPT_fbuiltin_strcat))
|
|
|
|
CmdArgs.push_back("-fno-builtin-strcat");
|
|
|
|
if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
|
|
|
|
CmdArgs.push_back("-fno-builtin-strcpy");
|
|
|
|
}
|
2009-09-10 12:57:27 +08:00
|
|
|
#endif
|
2009-09-10 11:37:02 +08:00
|
|
|
|
2011-03-19 05:23:40 +08:00
|
|
|
// Only allow -traditional or -traditional-cpp outside in preprocessing modes.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_traditional,
|
2011-03-19 05:23:40 +08:00
|
|
|
options::OPT_traditional_cpp)) {
|
|
|
|
if (isa<PreprocessJobAction>(JA))
|
|
|
|
CmdArgs.push_back("-traditional-cpp");
|
2011-08-19 08:30:14 +08:00
|
|
|
else
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
|
2011-03-19 05:23:40 +08:00
|
|
|
}
|
2009-07-15 05:58:17 +08:00
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_dM);
|
2009-04-12 09:56:53 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_dD);
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2010-04-15 14:09:03 +08:00
|
|
|
// Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
|
|
|
|
// parser.
|
2009-03-18 18:01:51 +08:00
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
|
2010-04-15 14:09:03 +08:00
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
2010-06-12 06:00:13 +08:00
|
|
|
(*it)->claim();
|
2010-04-17 14:10:00 +08:00
|
|
|
|
2010-04-15 14:09:03 +08:00
|
|
|
// We translate this by hand to the -cc1 argument, since nightly test uses
|
|
|
|
// it and developers have been trained to spell it with -mllvm.
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
|
2010-04-15 14:09:03 +08:00
|
|
|
CmdArgs.push_back("-disable-llvm-optzns");
|
|
|
|
else
|
2010-06-12 06:00:13 +08:00
|
|
|
(*it)->render(Args, CmdArgs);
|
2010-04-15 14:09:03 +08:00
|
|
|
}
|
2009-03-18 18:01:51 +08:00
|
|
|
|
2009-03-30 14:36:42 +08:00
|
|
|
if (Output.getType() == types::TY_Dependencies) {
|
|
|
|
// Handled with other dependency code.
|
2009-03-19 15:29:38 +08:00
|
|
|
} else if (Output.isFilename()) {
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-o");
|
2009-03-19 15:29:38 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
2009-03-18 16:07:30 +08:00
|
|
|
}
|
|
|
|
|
2009-03-18 18:01:51 +08:00
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
CmdArgs.push_back("-x");
|
|
|
|
CmdArgs.push_back(types::getTypeName(II.getType()));
|
2010-08-02 10:38:21 +08:00
|
|
|
if (II.isFilename())
|
2009-03-19 15:29:38 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-03-18 18:01:51 +08:00
|
|
|
else
|
2009-03-19 15:29:38 +08:00
|
|
|
II.getInputArg().renderAsInput(Args, CmdArgs);
|
2009-03-18 18:01:51 +08:00
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-11-04 03:50:27 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_undef);
|
|
|
|
|
2010-07-19 05:16:15 +08:00
|
|
|
const char *Exec = getToolChain().getDriver().getClangProgramPath();
|
2009-12-18 10:43:17 +08:00
|
|
|
|
|
|
|
// Optionally embed the -cc1 level arguments into the debug info, for build
|
|
|
|
// analysis.
|
|
|
|
if (getToolChain().UseDwarfDebugFlags()) {
|
2010-06-05 02:47:06 +08:00
|
|
|
ArgStringList OriginalArgs;
|
|
|
|
for (ArgList::const_iterator it = Args.begin(),
|
|
|
|
ie = Args.end(); it != ie; ++it)
|
|
|
|
(*it)->render(Args, OriginalArgs);
|
2010-08-25 00:47:49 +08:00
|
|
|
|
2009-12-18 10:43:17 +08:00
|
|
|
llvm::SmallString<256> Flags;
|
|
|
|
Flags += Exec;
|
2010-06-05 02:47:06 +08:00
|
|
|
for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
|
2009-12-18 10:43:17 +08:00
|
|
|
Flags += " ";
|
2010-06-05 02:47:06 +08:00
|
|
|
Flags += OriginalArgs[i];
|
2009-12-18 10:43:17 +08:00
|
|
|
}
|
|
|
|
CmdArgs.push_back("-dwarf-debug-flags");
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(Flags.str()));
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
Driver: Add two special groups of "whitelisted" options which we know
clang doesn't support, and don't want to warn are unused. Eventually
these should disappear.
Here is a more readable list than is in the diff:
W options: -Wall, -Wcast-align, -Wchar-align, -Wchar-subscripts,
-Werror, -Wextra, -Winline, -Wint-to-pointer-cast, -Wmissing-braces,
-Wmost, -Wnested-externs, -Wno-format-y2k, -Wno-four-char-constants,
-Wno-missing-field-initializers, -Wno-trigraphs, -Wno-unknown-pragmas,
-Wno-unused-parameter, -Wparentheses, -Wpointer-arith,
-Wpointer-to-int-cast, -Wreturn-type, -Wshorten-64-to-32, -Wswitch,
-Wunused-function, -Wunused-label, -Wunused-value, -Wunused-variable,
-Wwrite-strings.
f options: -fasm-blocks, -fmessage-length=.
llvm-svn: 67549
2009-03-24 03:03:36 +08:00
|
|
|
|
2011-02-11 00:52:03 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_pg))
|
|
|
|
if (Args.hasArg(options::OPT_fomit_frame_pointer))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_not_allowed_with)
|
2011-02-11 00:52:03 +08:00
|
|
|
<< "-fomit-frame-pointer" << A->getAsString(Args);
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2009-04-04 04:51:31 +08:00
|
|
|
// Claim some arguments which clang supports automatically.
|
|
|
|
|
2010-04-15 14:18:42 +08:00
|
|
|
// -fpch-preprocess is used with gcc to add a special marker in the output to
|
|
|
|
// include the PCH file. Clang's PTH solution is completely transparent, so we
|
|
|
|
// do not need to deal with it at all.
|
2009-04-04 04:51:31 +08:00
|
|
|
Args.ClaimAllArgs(options::OPT_fpch_preprocess);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
Driver: Add two special groups of "whitelisted" options which we know
clang doesn't support, and don't want to warn are unused. Eventually
these should disappear.
Here is a more readable list than is in the diff:
W options: -Wall, -Wcast-align, -Wchar-align, -Wchar-subscripts,
-Werror, -Wextra, -Winline, -Wint-to-pointer-cast, -Wmissing-braces,
-Wmost, -Wnested-externs, -Wno-format-y2k, -Wno-four-char-constants,
-Wno-missing-field-initializers, -Wno-trigraphs, -Wno-unknown-pragmas,
-Wno-unused-parameter, -Wparentheses, -Wpointer-arith,
-Wpointer-to-int-cast, -Wreturn-type, -Wshorten-64-to-32, -Wswitch,
-Wunused-function, -Wunused-label, -Wunused-value, -Wunused-variable,
-Wwrite-strings.
f options: -fasm-blocks, -fmessage-length=.
llvm-svn: 67549
2009-03-24 03:03:36 +08:00
|
|
|
// Claim some arguments which clang doesn't support, but we don't
|
|
|
|
// care to warn the user about.
|
2009-11-25 19:53:23 +08:00
|
|
|
Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
|
|
|
|
Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
|
2011-03-01 07:29:45 +08:00
|
|
|
|
2011-03-01 13:25:27 +08:00
|
|
|
// Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
|
2011-03-01 07:29:45 +08:00
|
|
|
Args.ClaimAllArgs(options::OPT_use_gold_plugin);
|
2011-03-01 13:25:27 +08:00
|
|
|
Args.ClaimAllArgs(options::OPT_emit_llvm);
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
|
|
|
|
2010-05-21 05:30:13 +08:00
|
|
|
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
assert(Inputs.size() == 1 && "Unexpected number of inputs.");
|
|
|
|
const InputInfo &Input = Inputs[0];
|
|
|
|
|
2010-11-18 06:13:25 +08:00
|
|
|
// Don't warn about "clang -w -c foo.s"
|
|
|
|
Args.ClaimAllArgs(options::OPT_w);
|
2011-03-01 13:25:27 +08:00
|
|
|
// and "clang -emit-llvm -c foo.s"
|
|
|
|
Args.ClaimAllArgs(options::OPT_emit_llvm);
|
|
|
|
// and "clang -use-gold-plugin -c foo.s"
|
|
|
|
Args.ClaimAllArgs(options::OPT_use_gold_plugin);
|
2010-11-18 06:13:25 +08:00
|
|
|
|
2010-05-21 05:30:13 +08:00
|
|
|
// Invoke ourselves in -cc1as mode.
|
|
|
|
//
|
|
|
|
// FIXME: Implement custom jobs for internal actions.
|
|
|
|
CmdArgs.push_back("-cc1as");
|
|
|
|
|
|
|
|
// Add the "effective" target triple.
|
|
|
|
CmdArgs.push_back("-triple");
|
2010-08-24 06:35:37 +08:00
|
|
|
std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
|
2010-05-21 05:30:13 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(TripleStr));
|
|
|
|
|
|
|
|
// Set the output mode, we currently only expect to be used as a real
|
|
|
|
// assembler.
|
|
|
|
CmdArgs.push_back("-filetype");
|
|
|
|
CmdArgs.push_back("obj");
|
|
|
|
|
2011-05-06 22:35:16 +08:00
|
|
|
if (UseRelaxAll(C, Args))
|
2010-05-29 00:43:21 +08:00
|
|
|
CmdArgs.push_back("-relax-all");
|
2010-05-27 14:18:05 +08:00
|
|
|
|
2011-03-18 01:37:29 +08:00
|
|
|
// Ignore explicit -force_cpusubtype_ALL option.
|
|
|
|
(void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
|
2010-05-21 05:30:13 +08:00
|
|
|
|
|
|
|
// FIXME: Add -g support, once we have it.
|
|
|
|
|
|
|
|
// FIXME: Add -static support, once we have it.
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
2011-04-30 01:53:18 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
|
2010-05-21 05:30:13 +08:00
|
|
|
|
|
|
|
assert(Output.isFilename() && "Unexpected lipo output.");
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
assert(Input.isFilename() && "Invalid input.");
|
|
|
|
CmdArgs.push_back(Input.getFilename());
|
2010-05-21 05:30:13 +08:00
|
|
|
|
2010-07-19 05:16:15 +08:00
|
|
|
const char *Exec = getToolChain().getDriver().getClangProgramPath();
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2010-05-21 05:30:13 +08:00
|
|
|
}
|
|
|
|
|
2009-03-18 16:07:30 +08:00
|
|
|
void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
2009-03-18 18:01:51 +08:00
|
|
|
const ArgList &Args,
|
2009-03-18 16:07:30 +08:00
|
|
|
const char *LinkingOutput) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-03-18 16:07:30 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
for (ArgList::const_iterator
|
2009-03-18 18:01:51 +08:00
|
|
|
it = Args.begin(), ie = Args.end(); it != ie; ++it) {
|
2009-03-18 16:07:30 +08:00
|
|
|
Arg *A = *it;
|
2009-03-19 15:55:12 +08:00
|
|
|
if (A->getOption().hasForwardToGCC()) {
|
2010-08-04 00:14:14 +08:00
|
|
|
// Don't forward any -g arguments to assembly steps.
|
|
|
|
if (isa<AssembleJobAction>(JA) &&
|
|
|
|
A->getOption().matches(options::OPT_g_Group))
|
|
|
|
continue;
|
|
|
|
|
2009-03-19 15:55:12 +08:00
|
|
|
// It is unfortunate that we have to claim here, as this means
|
|
|
|
// we will basically never report anything interesting for
|
2009-05-03 05:41:52 +08:00
|
|
|
// platforms using a generic gcc, even if we are just using gcc
|
|
|
|
// to get to the assembler.
|
2009-03-19 15:55:12 +08:00
|
|
|
A->claim();
|
2009-03-18 18:01:51 +08:00
|
|
|
A->render(Args, CmdArgs);
|
2009-03-19 15:55:12 +08:00
|
|
|
}
|
2009-03-18 16:07:30 +08:00
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
RenderExtraToolArgs(JA, CmdArgs);
|
2009-03-18 16:07:30 +08:00
|
|
|
|
|
|
|
// If using a driver driver, force the arch.
|
2009-05-22 10:21:04 +08:00
|
|
|
const std::string &Arch = getToolChain().getArchName();
|
2009-12-23 08:46:38 +08:00
|
|
|
if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) {
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-arch");
|
2009-04-02 04:33:11 +08:00
|
|
|
|
|
|
|
// FIXME: Remove these special cases.
|
2009-05-22 10:21:04 +08:00
|
|
|
if (Arch == "powerpc")
|
|
|
|
CmdArgs.push_back("ppc");
|
|
|
|
else if (Arch == "powerpc64")
|
|
|
|
CmdArgs.push_back("ppc64");
|
|
|
|
else
|
2009-09-10 06:32:48 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(Arch));
|
2009-03-18 16:07:30 +08:00
|
|
|
}
|
|
|
|
|
2009-05-03 05:41:52 +08:00
|
|
|
// Try to force gcc to match the tool chain we want, if we recognize
|
|
|
|
// the arch.
|
2009-05-22 10:21:04 +08:00
|
|
|
//
|
|
|
|
// FIXME: The triple class should directly provide the information we want
|
|
|
|
// here.
|
|
|
|
if (Arch == "i386" || Arch == "powerpc")
|
2009-05-03 05:41:52 +08:00
|
|
|
CmdArgs.push_back("-m32");
|
2009-05-22 10:21:04 +08:00
|
|
|
else if (Arch == "x86_64" || Arch == "powerpc64")
|
2009-05-03 05:41:52 +08:00
|
|
|
CmdArgs.push_back("-m64");
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-o");
|
2009-03-19 15:29:38 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Unexpected output");
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-fsyntax-only");
|
2009-03-19 15:29:38 +08:00
|
|
|
}
|
2009-03-18 16:07:30 +08:00
|
|
|
|
|
|
|
|
|
|
|
// Only pass -x if gcc will understand it; otherwise hope gcc
|
|
|
|
// understands the suffix correctly. The main use case this would go
|
|
|
|
// wrong in is for linker inputs if they happened to have an odd
|
|
|
|
// suffix; really the only way to get this to happen is a command
|
|
|
|
// like '-x foobar a.c' which will treat a.c like a linker input.
|
|
|
|
//
|
|
|
|
// FIXME: For the linker case specifically, can we safely convert
|
|
|
|
// inputs into '-Wl,' options?
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2009-05-03 04:14:53 +08:00
|
|
|
|
2009-09-02 00:57:46 +08:00
|
|
|
// Don't try to pass LLVM or AST inputs to a generic gcc.
|
2010-06-08 07:28:45 +08:00
|
|
|
if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
|
|
|
|
II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_no_linker_llvm_support)
|
2009-09-10 06:32:48 +08:00
|
|
|
<< getToolChain().getTripleString();
|
2009-09-02 00:57:46 +08:00
|
|
|
else if (II.getType() == types::TY_AST)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_no_ast_support)
|
2009-09-10 06:32:48 +08:00
|
|
|
<< getToolChain().getTripleString();
|
2009-05-03 04:14:53 +08:00
|
|
|
|
2009-03-18 16:07:30 +08:00
|
|
|
if (types::canTypeBeUserSpecified(II.getType())) {
|
|
|
|
CmdArgs.push_back("-x");
|
|
|
|
CmdArgs.push_back(types::getTypeName(II.getType()));
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (II.isFilename())
|
2009-03-19 15:29:38 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2010-09-26 02:10:05 +08:00
|
|
|
else {
|
|
|
|
const Arg &A = II.getInputArg();
|
|
|
|
|
|
|
|
// Reverse translate some rewritten options.
|
|
|
|
if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
|
|
|
|
CmdArgs.push_back("-lstdc++");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-03-19 15:29:38 +08:00
|
|
|
// Don't render as input, we need gcc to do the translations.
|
2010-09-26 02:10:05 +08:00
|
|
|
A.render(Args, CmdArgs);
|
|
|
|
}
|
2009-03-18 16:07:30 +08:00
|
|
|
}
|
|
|
|
|
2011-04-09 21:31:59 +08:00
|
|
|
const std::string customGCCName = D.getCCCGenericGCCName();
|
|
|
|
const char *GCCName;
|
|
|
|
if (!customGCCName.empty())
|
|
|
|
GCCName = customGCCName.c_str();
|
|
|
|
else if (D.CCCIsCXX) {
|
|
|
|
#ifdef IS_CYGWIN15
|
|
|
|
// FIXME: Detect the version of Cygwin at runtime?
|
|
|
|
GCCName = "g++-4";
|
|
|
|
#else
|
|
|
|
GCCName = "g++";
|
|
|
|
#endif
|
|
|
|
} else
|
|
|
|
GCCName = "gcc";
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-E");
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2009-03-18 16:07:30 +08:00
|
|
|
// The type is good enough.
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2010-02-11 11:16:21 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
// If -flto, etc. are present then make sure not to force assembly output.
|
2010-06-08 07:28:45 +08:00
|
|
|
if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
|
|
|
|
JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
|
2010-01-26 06:35:08 +08:00
|
|
|
CmdArgs.push_back("-c");
|
2010-02-11 11:16:21 +08:00
|
|
|
else {
|
|
|
|
if (JA.getType() != types::TY_PP_Asm)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_invalid_gcc_output_type)
|
2010-02-11 11:16:21 +08:00
|
|
|
<< getTypeName(JA.getType());
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
CmdArgs.push_back("-S");
|
2010-02-11 11:16:21 +08:00
|
|
|
}
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2009-03-18 16:07:30 +08:00
|
|
|
CmdArgs.push_back("-c");
|
|
|
|
}
|
2009-03-18 14:00:36 +08:00
|
|
|
|
2010-01-26 06:35:08 +08:00
|
|
|
void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2009-03-18 16:07:30 +08:00
|
|
|
// The types are (hopefully) good enough.
|
2009-03-18 14:00:36 +08:00
|
|
|
}
|
2009-03-18 16:07:30 +08:00
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
const char *darwin::CC1::getCC1Name(types::ID Type) const {
|
|
|
|
switch (Type) {
|
|
|
|
default:
|
|
|
|
assert(0 && "Unexpected type for Darwin CC1 tool.");
|
|
|
|
case types::TY_Asm:
|
|
|
|
case types::TY_C: case types::TY_CHeader:
|
|
|
|
case types::TY_PP_C: case types::TY_PP_CHeader:
|
|
|
|
return "cc1";
|
|
|
|
case types::TY_ObjC: case types::TY_ObjCHeader:
|
2011-08-14 07:13:37 +08:00
|
|
|
case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias:
|
|
|
|
case types::TY_PP_ObjCHeader:
|
2009-03-30 01:08:39 +08:00
|
|
|
return "cc1obj";
|
|
|
|
case types::TY_CXX: case types::TY_CXXHeader:
|
|
|
|
case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
|
|
|
|
return "cc1plus";
|
|
|
|
case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
|
2011-08-14 07:13:37 +08:00
|
|
|
case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias:
|
|
|
|
case types::TY_PP_ObjCXXHeader:
|
2009-03-30 01:08:39 +08:00
|
|
|
return "cc1objplus";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *darwin::CC1::getBaseInputName(const ArgList &Args,
|
2009-03-30 08:34:04 +08:00
|
|
|
const InputInfoList &Inputs) {
|
2010-12-18 08:19:12 +08:00
|
|
|
return Args.MakeArgString(
|
|
|
|
llvm::sys::path::filename(Inputs[0].getBaseInput()));
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
|
2009-03-30 08:34:04 +08:00
|
|
|
const InputInfoList &Inputs) {
|
2009-03-30 02:40:18 +08:00
|
|
|
const char *Str = getBaseInputName(Args, Inputs);
|
|
|
|
|
2011-01-16 16:14:11 +08:00
|
|
|
if (const char *End = strrchr(Str, '.'))
|
2009-09-10 06:32:48 +08:00
|
|
|
return Args.MakeArgString(std::string(Str, End));
|
2009-03-30 02:40:18 +08:00
|
|
|
|
|
|
|
return Str;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
2009-04-09 07:54:23 +08:00
|
|
|
darwin::CC1::getDependencyFileName(const ArgList &Args,
|
2009-03-30 08:34:04 +08:00
|
|
|
const InputInfoList &Inputs) {
|
2009-03-30 02:40:18 +08:00
|
|
|
// FIXME: Think about this more.
|
|
|
|
std::string Res;
|
|
|
|
|
|
|
|
if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
|
|
|
|
std::string Str(OutputOpt->getValue(Args));
|
|
|
|
Res = Str.substr(0, Str.rfind('.'));
|
2011-08-18 07:08:45 +08:00
|
|
|
} else {
|
2009-03-30 08:34:04 +08:00
|
|
|
Res = darwin::CC1::getBaseInputStem(Args, Inputs);
|
2011-08-18 07:08:45 +08:00
|
|
|
}
|
2009-09-10 06:32:48 +08:00
|
|
|
return Args.MakeArgString(Res + ".d");
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
2011-08-18 02:24:55 +08:00
|
|
|
void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const {
|
2011-08-19 08:30:14 +08:00
|
|
|
for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end();
|
2011-08-18 02:24:55 +08:00
|
|
|
it != ie;) {
|
2011-08-19 01:56:32 +08:00
|
|
|
|
|
|
|
StringRef Option = *it;
|
2011-08-27 02:30:43 +08:00
|
|
|
bool RemoveOption = false;
|
2011-08-18 09:18:28 +08:00
|
|
|
|
2011-08-27 02:30:43 +08:00
|
|
|
// Remove -faltivec
|
|
|
|
if (Option.equals("-faltivec")) {
|
|
|
|
it = CmdArgs.erase(it);
|
|
|
|
ie = CmdArgs.end();
|
2011-08-18 09:18:28 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-08-27 02:30:43 +08:00
|
|
|
// Handle machine specific options.
|
|
|
|
if (Option.startswith("-m")) {
|
|
|
|
RemoveOption = llvm::StringSwitch<bool>(Option)
|
|
|
|
.Case("-mthumb", true)
|
|
|
|
.Case("-mno-thumb", true)
|
|
|
|
.Case("-mno-fused-madd", true)
|
|
|
|
.Case("-mlong-branch", true)
|
|
|
|
.Case("-mlongcall", true)
|
|
|
|
.Case("-mcpu=G4", true)
|
|
|
|
.Case("-mcpu=G5", true)
|
|
|
|
.Default(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle warning options.
|
|
|
|
if (Option.startswith("-W")) {
|
|
|
|
// Remove -W/-Wno- to reduce the number of cases.
|
|
|
|
if (Option.startswith("-Wno-"))
|
|
|
|
Option = Option.substr(5);
|
|
|
|
else
|
|
|
|
Option = Option.substr(2);
|
|
|
|
|
|
|
|
RemoveOption = llvm::StringSwitch<bool>(Option)
|
|
|
|
.Case("address-of-temporary", true)
|
|
|
|
.Case("ambiguous-member-template", true)
|
|
|
|
.Case("analyzer-incompatible-plugin", true)
|
|
|
|
.Case("array-bounds", true)
|
|
|
|
.Case("array-bounds-pointer-arithmetic", true)
|
|
|
|
.Case("bind-to-temporary-copy", true)
|
|
|
|
.Case("bitwise-op-parentheses", true)
|
|
|
|
.Case("bool-conversions", true)
|
|
|
|
.Case("builtin-macro-redefined", true)
|
|
|
|
.Case("c++-hex-floats", true)
|
|
|
|
.Case("c++0x-compat", true)
|
|
|
|
.Case("c++0x-extensions", true)
|
|
|
|
.Case("c++0x-narrowing", true)
|
|
|
|
.Case("c++0x-static-nonintegral-init", true)
|
|
|
|
.Case("conditional-uninitialized", true)
|
|
|
|
.Case("constant-conversion", true)
|
|
|
|
.Case("CFString-literal", true)
|
|
|
|
.Case("constant-logical-operand", true)
|
|
|
|
.Case("custom-atomic-properties", true)
|
|
|
|
.Case("default-arg-special-member", true)
|
|
|
|
.Case("delegating-ctor-cycles", true)
|
|
|
|
.Case("delete-non-virtual-dtor", true)
|
|
|
|
.Case("deprecated-implementations", true)
|
|
|
|
.Case("deprecated-writable-strings", true)
|
|
|
|
.Case("distributed-object-modifiers", true)
|
|
|
|
.Case("duplicate-method-arg", true)
|
|
|
|
.Case("dynamic-class-memaccess", true)
|
|
|
|
.Case("enum-compare", true)
|
|
|
|
.Case("exit-time-destructors", true)
|
|
|
|
.Case("gnu", true)
|
|
|
|
.Case("gnu-designator", true)
|
|
|
|
.Case("header-hygiene", true)
|
|
|
|
.Case("idiomatic-parentheses", true)
|
|
|
|
.Case("ignored-qualifiers", true)
|
|
|
|
.Case("implicit-atomic-properties", true)
|
|
|
|
.Case("incompatible-pointer-types", true)
|
|
|
|
.Case("incomplete-implementation", true)
|
|
|
|
.Case("initializer-overrides", true)
|
|
|
|
.Case("invalid-noreturn", true)
|
|
|
|
.Case("invalid-token-paste", true)
|
|
|
|
.Case("literal-conversion", true)
|
|
|
|
.Case("literal-range", true)
|
|
|
|
.Case("local-type-template-args", true)
|
|
|
|
.Case("logical-op-parentheses", true)
|
|
|
|
.Case("method-signatures", true)
|
|
|
|
.Case("microsoft", true)
|
|
|
|
.Case("mismatched-tags", true)
|
|
|
|
.Case("missing-method-return-type", true)
|
|
|
|
.Case("non-pod-varargs", true)
|
|
|
|
.Case("nonfragile-abi2", true)
|
|
|
|
.Case("null-arithmetic", true)
|
|
|
|
.Case("null-dereference", true)
|
|
|
|
.Case("out-of-line-declaration", true)
|
|
|
|
.Case("overriding-method-mismatch", true)
|
|
|
|
.Case("readonly-setter-attrs", true)
|
|
|
|
.Case("return-stack-address", true)
|
|
|
|
.Case("self-assign", true)
|
|
|
|
.Case("semicolon-before-method-body", true)
|
|
|
|
.Case("sentinel", true)
|
|
|
|
.Case("shift-overflow", true)
|
|
|
|
.Case("shift-sign-overflow", true)
|
|
|
|
.Case("sign-conversion", true)
|
|
|
|
.Case("sizeof-array-argument", true)
|
|
|
|
.Case("sizeof-pointer-memaccess", true)
|
|
|
|
.Case("string-compare", true)
|
|
|
|
.Case("super-class-method-mismatch", true)
|
|
|
|
.Case("tautological-compare", true)
|
|
|
|
.Case("typedef-redefinition", true)
|
|
|
|
.Case("typename-missing", true)
|
|
|
|
.Case("undefined-reinterpret-cast", true)
|
|
|
|
.Case("unknown-warning-option", true)
|
|
|
|
.Case("unnamed-type-template-args", true)
|
|
|
|
.Case("unneeded-internal-declaration", true)
|
|
|
|
.Case("unneeded-member-function", true)
|
|
|
|
.Case("unused-comparison", true)
|
|
|
|
.Case("unused-exception-parameter", true)
|
|
|
|
.Case("unused-member-function", true)
|
|
|
|
.Case("unused-result", true)
|
|
|
|
.Case("vector-conversions", true)
|
|
|
|
.Case("vla", true)
|
|
|
|
.Case("used-but-marked-unused", true)
|
|
|
|
.Case("weak-vtables", true)
|
|
|
|
.Default(false);
|
|
|
|
} // if (Option.startswith("-W"))
|
2011-08-18 09:18:28 +08:00
|
|
|
if (RemoveOption) {
|
2011-08-18 02:24:55 +08:00
|
|
|
it = CmdArgs.erase(it);
|
2011-08-18 02:51:56 +08:00
|
|
|
ie = CmdArgs.end();
|
2011-08-18 07:08:45 +08:00
|
|
|
} else {
|
2011-08-18 02:24:55 +08:00
|
|
|
++it;
|
2011-08-18 07:08:45 +08:00
|
|
|
}
|
2011-08-18 02:24:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
void darwin::CC1::AddCC1Args(const ArgList &Args,
|
2009-03-30 02:40:18 +08:00
|
|
|
ArgStringList &CmdArgs) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-09-10 09:21:12 +08:00
|
|
|
|
|
|
|
CheckCodeGenerationOptions(D, Args);
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// Derived from cc1 spec.
|
|
|
|
if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
|
|
|
|
!Args.hasArg(options::OPT_mdynamic_no_pic))
|
|
|
|
CmdArgs.push_back("-fPIC");
|
|
|
|
|
2009-09-10 11:37:02 +08:00
|
|
|
if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
|
|
|
|
getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
|
|
|
|
if (!Args.hasArg(options::OPT_fbuiltin_strcat))
|
|
|
|
CmdArgs.push_back("-fno-builtin-strcat");
|
|
|
|
if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
|
|
|
|
CmdArgs.push_back("-fno-builtin-strcpy");
|
|
|
|
}
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
if (Args.hasArg(options::OPT_g_Flag) &&
|
|
|
|
!Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
|
|
|
|
CmdArgs.push_back("-feliminate-unused-debug-symbols");
|
|
|
|
}
|
|
|
|
|
|
|
|
void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgStringList &OutputArgs) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-03-30 02:40:18 +08:00
|
|
|
|
|
|
|
// Derived from cc1_options spec.
|
|
|
|
if (Args.hasArg(options::OPT_fast) ||
|
|
|
|
Args.hasArg(options::OPT_fastf) ||
|
|
|
|
Args.hasArg(options::OPT_fastcp))
|
|
|
|
CmdArgs.push_back("-O3");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_pg))
|
|
|
|
if (Args.hasArg(options::OPT_fomit_frame_pointer))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_not_allowed_with)
|
2009-03-30 02:40:18 +08:00
|
|
|
<< A->getAsString(Args) << "-fomit-frame-pointer";
|
|
|
|
|
|
|
|
AddCC1Args(Args, CmdArgs);
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_Q))
|
|
|
|
CmdArgs.push_back("-quiet");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-dumpbase");
|
2009-03-30 08:34:04 +08:00
|
|
|
CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
|
2009-03-30 02:40:18 +08:00
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
|
|
|
|
|
|
|
|
// FIXME: The goal is to use the user provided -o if that is our
|
|
|
|
// final output, otherwise to drive from the original input
|
|
|
|
// name. Find a clean way to go about this.
|
|
|
|
if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
|
|
|
|
Args.hasArg(options::OPT_o)) {
|
|
|
|
Arg *OutputOpt = Args.getLastArg(options::OPT_o);
|
|
|
|
CmdArgs.push_back("-auxbase-strip");
|
|
|
|
CmdArgs.push_back(OutputOpt->getValue(Args));
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-auxbase");
|
2009-03-30 08:34:04 +08:00
|
|
|
CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_O);
|
|
|
|
// FIXME: -Wall is getting some special treatment. Investigate.
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_w);
|
2009-04-09 07:54:23 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
|
2009-03-30 02:40:18 +08:00
|
|
|
options::OPT_trigraphs);
|
2009-04-26 09:10:38 +08:00
|
|
|
if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
|
|
|
|
// Honor -std-default.
|
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
|
|
|
|
"-std=", /*Joined=*/true);
|
|
|
|
}
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
if (Args.hasArg(options::OPT_v))
|
|
|
|
CmdArgs.push_back("-version");
|
2011-03-02 02:49:30 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg) &&
|
|
|
|
getToolChain().SupportsProfiling())
|
2009-03-30 02:40:18 +08:00
|
|
|
CmdArgs.push_back("-p");
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_p);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// The driver treats -fsyntax-only specially.
|
2009-09-10 11:37:02 +08:00
|
|
|
if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
|
|
|
|
getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
|
|
|
|
// Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
|
|
|
|
// used to inhibit the default -fno-builtin-str{cat,cpy}.
|
|
|
|
//
|
|
|
|
// FIXME: Should we grow a better way to deal with "removing" args?
|
2009-11-25 19:53:23 +08:00
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
|
|
|
|
options::OPT_fsyntax_only),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
2010-06-12 06:00:13 +08:00
|
|
|
if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
|
|
|
|
!(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
|
|
|
|
(*it)->claim();
|
|
|
|
(*it)->render(Args, CmdArgs);
|
2009-09-10 11:37:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2011-04-08 04:41:03 +08:00
|
|
|
// Claim Clang only -f options, they aren't worth warning about.
|
|
|
|
Args.ClaimAllArgs(options::OPT_f_clang_Group);
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_undef);
|
|
|
|
if (Args.hasArg(options::OPT_Qn))
|
|
|
|
CmdArgs.push_back("-fno-ident");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// FIXME: This isn't correct.
|
|
|
|
//Args.AddLastArg(CmdArgs, options::OPT__help)
|
|
|
|
//Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
|
|
|
|
|
|
|
|
CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
|
|
|
|
|
|
|
|
// FIXME: Still don't get what is happening here. Investigate.
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT__param);
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_fmudflap) ||
|
|
|
|
Args.hasArg(options::OPT_fmudflapth)) {
|
|
|
|
CmdArgs.push_back("-fno-builtin");
|
|
|
|
CmdArgs.push_back("-fno-merge-constants");
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
if (Args.hasArg(options::OPT_coverage)) {
|
|
|
|
CmdArgs.push_back("-fprofile-arcs");
|
|
|
|
CmdArgs.push_back("-ftest-coverage");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (types::isCXX(Inputs[0].getType()))
|
|
|
|
CmdArgs.push_back("-D__private_extern__=extern");
|
|
|
|
}
|
|
|
|
|
|
|
|
void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgStringList &OutputArgs) const {
|
|
|
|
// Derived from cpp_options
|
|
|
|
AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
|
|
|
|
|
|
|
|
AddCC1Args(Args, CmdArgs);
|
|
|
|
|
|
|
|
// NOTE: The code below has some commonality with cpp_options, but
|
|
|
|
// in classic gcc style ends up sending things in different
|
|
|
|
// orders. This may be a good merge candidate once we drop pedantic
|
|
|
|
// compatibility.
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
|
2009-04-09 07:54:23 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
|
2009-03-30 02:40:18 +08:00
|
|
|
options::OPT_trigraphs);
|
2009-04-26 09:10:38 +08:00
|
|
|
if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
|
|
|
|
// Honor -std-default.
|
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
|
|
|
|
"-std=", /*Joined=*/true);
|
|
|
|
}
|
2009-03-30 02:40:18 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_w);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// The driver treats -fsyntax-only specially.
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
|
|
|
|
|
2011-04-08 04:41:03 +08:00
|
|
|
// Claim Clang only -f options, they aren't worth warning about.
|
|
|
|
Args.ClaimAllArgs(options::OPT_f_clang_Group);
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
|
|
|
|
!Args.hasArg(options::OPT_fno_working_directory))
|
|
|
|
CmdArgs.push_back("-fworking-directory");
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_O);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_undef);
|
|
|
|
if (Args.hasArg(options::OPT_save_temps))
|
|
|
|
CmdArgs.push_back("-fpch-preprocess");
|
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
|
2009-03-30 02:40:18 +08:00
|
|
|
ArgStringList &CmdArgs,
|
2009-09-09 23:08:12 +08:00
|
|
|
const InputInfoList &Inputs) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-03-30 02:40:18 +08:00
|
|
|
|
2009-09-10 09:21:05 +08:00
|
|
|
CheckPreprocessingOptions(D, Args);
|
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// Derived from cpp_unique_options.
|
2009-09-10 09:21:05 +08:00
|
|
|
// -{C,CC} only with -E is checked in CheckPreprocessingOptions().
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_C);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_CC);
|
2009-03-30 02:40:18 +08:00
|
|
|
if (!Args.hasArg(options::OPT_Q))
|
|
|
|
CmdArgs.push_back("-quiet");
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
|
2010-03-25 04:13:48 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
|
2009-03-30 02:40:18 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_v);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_P);
|
|
|
|
|
|
|
|
// FIXME: Handle %I properly.
|
|
|
|
if (getToolChain().getArchName() == "x86_64") {
|
|
|
|
CmdArgs.push_back("-imultilib");
|
|
|
|
CmdArgs.push_back("x86_64");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_MD)) {
|
|
|
|
CmdArgs.push_back("-MD");
|
2009-03-30 08:34:04 +08:00
|
|
|
CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_MMD)) {
|
|
|
|
CmdArgs.push_back("-MMD");
|
2009-03-30 08:34:04 +08:00
|
|
|
CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_M);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_MM);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_MF);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_MG);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_MP);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_MQ);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_MT);
|
|
|
|
if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
|
|
|
|
(Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
|
|
|
|
if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
|
|
|
|
CmdArgs.push_back("-MQ");
|
|
|
|
CmdArgs.push_back(OutputOpt->getValue(Args));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_remap);
|
|
|
|
if (Args.hasArg(options::OPT_g3))
|
|
|
|
CmdArgs.push_back("-dD");
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_H);
|
|
|
|
|
|
|
|
AddCPPArgs(Args, CmdArgs);
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
|
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-03-30 02:40:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
|
|
|
|
options::OPT_Xpreprocessor);
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_fmudflap)) {
|
|
|
|
CmdArgs.push_back("-D_MUDFLAP");
|
|
|
|
CmdArgs.push_back("-include");
|
|
|
|
CmdArgs.push_back("mf-runtime.h");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_fmudflapth)) {
|
|
|
|
CmdArgs.push_back("-D_MUDFLAP");
|
|
|
|
CmdArgs.push_back("-D_MUDFLAPTH");
|
|
|
|
CmdArgs.push_back("-include");
|
|
|
|
CmdArgs.push_back("mf-runtime.h");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
void darwin::CC1::AddCPPArgs(const ArgList &Args,
|
2009-03-30 02:40:18 +08:00
|
|
|
ArgStringList &CmdArgs) const {
|
|
|
|
// Derived from cpp spec.
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
// The gcc spec is broken here, it refers to dynamic but
|
|
|
|
// that has been translated. Start by being bug compatible.
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 02:40:18 +08:00
|
|
|
// if (!Args.hasArg(arglist.parser.dynamicOption))
|
|
|
|
CmdArgs.push_back("-D__STATIC__");
|
|
|
|
} else
|
|
|
|
CmdArgs.push_back("-D__DYNAMIC__");
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
|
|
|
CmdArgs.push_back("-D_REENTRANT");
|
|
|
|
}
|
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-03-30 01:08:39 +08:00
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
assert(Inputs.size() == 1 && "Unexpected number of inputs!");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-E");
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_traditional) ||
|
|
|
|
Args.hasArg(options::OPT_traditional_cpp))
|
|
|
|
CmdArgs.push_back("-traditional-cpp");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
ArgStringList OutputArgs;
|
2010-08-02 10:38:21 +08:00
|
|
|
assert(Output.isFilename() && "Unexpected CC1 output.");
|
|
|
|
OutputArgs.push_back("-o");
|
|
|
|
OutputArgs.push_back(Output.getFilename());
|
2009-03-30 01:08:39 +08:00
|
|
|
|
2011-03-07 07:31:01 +08:00
|
|
|
if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
|
2009-03-30 06:27:40 +08:00
|
|
|
AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
|
|
|
|
} else {
|
|
|
|
AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
|
|
|
|
CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-04-03 09:27:06 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
|
|
|
|
|
2011-09-08 08:38:00 +08:00
|
|
|
RemoveCC1UnsupportedArgs(CmdArgs);
|
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
const char *CC1Name = getCC1Name(Inputs[0].getType());
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-30 01:08:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-03-30 01:08:39 +08:00
|
|
|
const char *LinkingOutput) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-03-30 01:08:39 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
assert(Inputs.size() == 1 && "Unexpected number of inputs!");
|
|
|
|
|
|
|
|
types::ID InputType = Inputs[0].getType();
|
|
|
|
const Arg *A;
|
2009-07-15 05:58:17 +08:00
|
|
|
if ((A = Args.getLastArg(options::OPT_traditional)))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_only_allowed_with)
|
2009-03-30 01:08:39 +08:00
|
|
|
<< A->getAsString(Args) << "-E";
|
|
|
|
|
2010-06-08 07:28:45 +08:00
|
|
|
if (JA.getType() == types::TY_LLVM_IR ||
|
|
|
|
JA.getType() == types::TY_LTO_IR)
|
2009-03-30 01:08:39 +08:00
|
|
|
CmdArgs.push_back("-emit-llvm");
|
2010-06-08 07:28:45 +08:00
|
|
|
else if (JA.getType() == types::TY_LLVM_BC ||
|
|
|
|
JA.getType() == types::TY_LTO_BC)
|
2009-03-30 01:08:39 +08:00
|
|
|
CmdArgs.push_back("-emit-llvm-bc");
|
2009-09-02 00:57:46 +08:00
|
|
|
else if (Output.getType() == types::TY_AST)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_no_ast_support)
|
2009-09-10 06:32:48 +08:00
|
|
|
<< getToolChain().getTripleString();
|
2010-02-12 01:33:45 +08:00
|
|
|
else if (JA.getType() != types::TY_PP_Asm &&
|
|
|
|
JA.getType() != types::TY_PCH)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_invalid_gcc_output_type)
|
2010-02-11 11:16:21 +08:00
|
|
|
<< getTypeName(JA.getType());
|
2009-03-30 01:08:39 +08:00
|
|
|
|
|
|
|
ArgStringList OutputArgs;
|
|
|
|
if (Output.getType() != types::TY_PCH) {
|
|
|
|
OutputArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isNothing())
|
2009-03-30 01:08:39 +08:00
|
|
|
OutputArgs.push_back("/dev/null");
|
|
|
|
else
|
|
|
|
OutputArgs.push_back(Output.getFilename());
|
|
|
|
}
|
|
|
|
|
|
|
|
// There is no need for this level of compatibility, but it makes
|
|
|
|
// diffing easier.
|
|
|
|
bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
|
|
|
|
Args.hasArg(options::OPT_S));
|
|
|
|
|
|
|
|
if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
|
2009-03-30 02:40:18 +08:00
|
|
|
AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
|
2009-03-30 01:08:39 +08:00
|
|
|
if (OutputArgsEarly) {
|
|
|
|
AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
|
|
|
|
} else {
|
|
|
|
AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
|
|
|
|
CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-fpreprocessed");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
|
2009-09-02 00:57:46 +08:00
|
|
|
// Reject AST inputs.
|
|
|
|
if (II.getType() == types::TY_AST) {
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_no_ast_support)
|
2009-09-10 06:32:48 +08:00
|
|
|
<< getToolChain().getTripleString();
|
2009-09-02 00:57:46 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-03-30 01:08:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (OutputArgsEarly) {
|
|
|
|
AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
|
|
|
|
} else {
|
|
|
|
AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
|
|
|
|
CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
|
|
|
|
}
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
if (Output.getType() == types::TY_PCH) {
|
|
|
|
assert(Output.isFilename() && "Invalid PCH output.");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
// NOTE: gcc uses a temp .s file for this, but there doesn't seem
|
|
|
|
// to be a good reason.
|
2011-08-02 03:58:48 +08:00
|
|
|
const char *TmpPath = C.getArgs().MakeArgString(
|
2011-08-27 05:28:44 +08:00
|
|
|
D.GetTemporaryPath("cc", "s"));
|
2011-08-02 03:58:48 +08:00
|
|
|
C.addTempFile(TmpPath);
|
|
|
|
CmdArgs.push_back(TmpPath);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2011-08-19 08:30:14 +08:00
|
|
|
// If we're emitting a pch file with the last 4 characters of ".pth"
|
|
|
|
// and falling back to llvm-gcc we want to use ".gch" instead.
|
|
|
|
std::string OutputFile(Output.getFilename());
|
|
|
|
size_t loc = OutputFile.rfind(".pth");
|
|
|
|
if (loc != std::string::npos)
|
|
|
|
OutputFile.replace(loc, 4, ".gch");
|
|
|
|
const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile);
|
|
|
|
CmdArgs.push_back(Tmp);
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
2009-03-30 01:08:39 +08:00
|
|
|
|
2011-08-18 02:24:55 +08:00
|
|
|
RemoveCC1UnsupportedArgs(CmdArgs);
|
|
|
|
|
2009-03-30 01:08:39 +08:00
|
|
|
const char *CC1Name = getCC1Name(Inputs[0].getType());
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-30 01:08:39 +08:00
|
|
|
}
|
|
|
|
|
2009-03-21 00:06:39 +08:00
|
|
|
void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-03-21 00:06:39 +08:00
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
assert(Inputs.size() == 1 && "Unexpected number of inputs.");
|
|
|
|
const InputInfo &Input = Inputs[0];
|
|
|
|
|
2011-04-13 07:59:20 +08:00
|
|
|
// Determine the original source input.
|
|
|
|
const Action *SourceAction = &JA;
|
|
|
|
while (SourceAction->getKind() != Action::InputClass) {
|
|
|
|
assert(!SourceAction->getInputs().empty() && "unexpected root action!");
|
|
|
|
SourceAction = SourceAction->getInputs()[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Forward -g, assuming we are dealing with an actual assembly file.
|
2011-08-19 08:30:14 +08:00
|
|
|
if (SourceAction->getType() == types::TY_Asm ||
|
2011-04-13 07:59:20 +08:00
|
|
|
SourceAction->getType() == types::TY_PP_Asm) {
|
2009-04-01 08:27:44 +08:00
|
|
|
if (Args.hasArg(options::OPT_gstabs))
|
|
|
|
CmdArgs.push_back("--gstabs");
|
|
|
|
else if (Args.hasArg(options::OPT_g_Group))
|
|
|
|
CmdArgs.push_back("--gdwarf2");
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-21 00:06:39 +08:00
|
|
|
// Derived from asm spec.
|
2009-09-10 02:36:27 +08:00
|
|
|
AddDarwinArch(Args, CmdArgs);
|
|
|
|
|
2010-07-22 09:47:22 +08:00
|
|
|
// Use -force_cpusubtype_ALL on x86 by default.
|
|
|
|
if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
|
|
|
|
getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
|
2009-09-10 02:36:27 +08:00
|
|
|
Args.hasArg(options::OPT_force__cpusubtype__ALL))
|
|
|
|
CmdArgs.push_back("-force_cpusubtype_ALL");
|
2009-03-21 00:06:39 +08:00
|
|
|
|
2009-08-25 06:26:16 +08:00
|
|
|
if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
|
|
|
|
(Args.hasArg(options::OPT_mkernel) ||
|
2009-03-21 00:06:39 +08:00
|
|
|
Args.hasArg(options::OPT_static) ||
|
2009-08-25 06:26:16 +08:00
|
|
|
Args.hasArg(options::OPT_fapple_kext)))
|
2009-04-09 07:54:23 +08:00
|
|
|
CmdArgs.push_back("-static");
|
|
|
|
|
2009-03-21 00:06:39 +08:00
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
assert(Output.isFilename() && "Unexpected lipo output.");
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
assert(Input.isFilename() && "Invalid input.");
|
|
|
|
CmdArgs.push_back(Input.getFilename());
|
2009-03-21 00:06:39 +08:00
|
|
|
|
|
|
|
// asm_final spec is empty.
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("as"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-21 00:06:39 +08:00
|
|
|
}
|
2009-03-20 08:52:38 +08:00
|
|
|
|
2009-09-10 02:36:20 +08:00
|
|
|
void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
|
2010-01-22 10:04:58 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
// Derived from darwin_arch spec.
|
|
|
|
CmdArgs.push_back("-arch");
|
2010-01-22 10:04:58 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(ArchName));
|
2009-09-05 02:35:31 +08:00
|
|
|
|
2010-01-22 10:04:58 +08:00
|
|
|
// FIXME: Is this needed anymore?
|
|
|
|
if (ArchName == "arm")
|
2009-09-05 02:35:31 +08:00
|
|
|
CmdArgs.push_back("-force_cpusubtype_ALL");
|
2009-03-27 00:23:12 +08:00
|
|
|
}
|
|
|
|
|
2010-09-10 05:51:05 +08:00
|
|
|
void darwin::Link::AddLinkArgs(Compilation &C,
|
|
|
|
const ArgList &Args,
|
2009-03-27 00:23:12 +08:00
|
|
|
ArgStringList &CmdArgs) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2011-04-29 05:23:41 +08:00
|
|
|
const toolchains::Darwin &DarwinTC = getDarwinToolChain();
|
2009-03-27 00:23:12 +08:00
|
|
|
|
2010-08-12 07:07:50 +08:00
|
|
|
unsigned Version[3] = { 0, 0, 0 };
|
|
|
|
if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
|
|
|
|
bool HadExtra;
|
|
|
|
if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
|
|
|
|
Version[1], Version[2], HadExtra) ||
|
|
|
|
HadExtra)
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_invalid_version_number)
|
2010-08-12 07:07:50 +08:00
|
|
|
<< A->getAsString(Args);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Newer linkers support -demangle, pass it if supported and not disabled by
|
|
|
|
// the user.
|
2010-11-20 01:51:40 +08:00
|
|
|
//
|
|
|
|
// FIXME: We temporarily avoid passing -demangle to any iOS linker, because
|
|
|
|
// unfortunately we can't be guaranteed that the linker version used there
|
|
|
|
// will match the linker version detected at configure time. We need the
|
|
|
|
// universal driver.
|
|
|
|
if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
|
2011-04-29 05:23:41 +08:00
|
|
|
!DarwinTC.isTargetIPhoneOS()) {
|
2010-09-08 01:07:49 +08:00
|
|
|
// Don't pass -demangle to ld_classic.
|
|
|
|
//
|
|
|
|
// FIXME: This is a temporary workaround, ld should be handling this.
|
|
|
|
bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
|
|
|
|
Args.hasArg(options::OPT_static));
|
2010-09-08 01:50:41 +08:00
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86) {
|
|
|
|
for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
|
|
|
|
options::OPT_Wl_COMMA),
|
|
|
|
ie = Args.filtered_end(); it != ie; ++it) {
|
|
|
|
const Arg *A = *it;
|
|
|
|
for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
|
2011-07-23 18:55:15 +08:00
|
|
|
if (StringRef(A->getValue(Args, i)) == "-kext")
|
2010-09-08 01:50:41 +08:00
|
|
|
UsesLdClassic = true;
|
|
|
|
}
|
|
|
|
}
|
2010-09-08 01:07:49 +08:00
|
|
|
if (!UsesLdClassic)
|
|
|
|
CmdArgs.push_back("-demangle");
|
2010-08-12 07:07:50 +08:00
|
|
|
}
|
|
|
|
|
2011-06-22 04:55:11 +08:00
|
|
|
// If we are using LTO, then automatically create a temporary file path for
|
|
|
|
// the linker to use, so that it's lifetime will extend past a possible
|
|
|
|
// dsymutil step.
|
2011-06-22 05:18:32 +08:00
|
|
|
if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
|
2011-06-22 04:55:11 +08:00
|
|
|
const char *TmpPath = C.getArgs().MakeArgString(
|
2011-08-27 05:28:44 +08:00
|
|
|
D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
|
2011-06-22 04:55:11 +08:00
|
|
|
C.addTempFile(TmpPath);
|
|
|
|
CmdArgs.push_back("-object_path_lto");
|
|
|
|
CmdArgs.push_back(TmpPath);
|
|
|
|
}
|
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
// Derived from the "link" spec.
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_static);
|
|
|
|
if (!Args.hasArg(options::OPT_static))
|
|
|
|
CmdArgs.push_back("-dynamic");
|
|
|
|
if (Args.hasArg(options::OPT_fgnu_runtime)) {
|
|
|
|
// FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
|
|
|
|
// here. How do we wish to handle such things?
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
if (!Args.hasArg(options::OPT_dynamiclib)) {
|
2010-01-22 10:04:52 +08:00
|
|
|
AddDarwinArch(Args, CmdArgs);
|
|
|
|
// FIXME: Why do this only on this path?
|
2010-01-22 11:37:33 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
|
2009-03-27 00:23:12 +08:00
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_bundle);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_client__name);
|
|
|
|
|
|
|
|
Arg *A;
|
|
|
|
if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_current__version)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_install__name)))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_only_allowed_with)
|
2009-03-27 00:23:12 +08:00
|
|
|
<< A->getAsString(Args) << "-dynamiclib";
|
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-dylib");
|
|
|
|
|
|
|
|
Arg *A;
|
|
|
|
if ((A = Args.getLastArg(options::OPT_bundle)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_bundle__loader)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_client__name)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_keep__private__externs)) ||
|
|
|
|
(A = Args.getLastArg(options::OPT_private__bundle)))
|
2011-07-23 18:55:15 +08:00
|
|
|
D.Diag(diag::err_drv_argument_not_allowed_with)
|
2009-03-27 00:23:12 +08:00
|
|
|
<< A->getAsString(Args) << "-dynamiclib";
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
|
|
|
|
"-dylib_compatibility_version");
|
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
|
|
|
|
"-dylib_current_version");
|
|
|
|
|
2010-01-22 10:04:52 +08:00
|
|
|
AddDarwinArch(Args, CmdArgs);
|
2009-03-27 00:23:12 +08:00
|
|
|
|
|
|
|
Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
|
|
|
|
"-dylib_install_name");
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_all__load);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
|
2011-04-29 05:23:41 +08:00
|
|
|
if (DarwinTC.isTargetIPhoneOS())
|
2009-09-05 02:35:41 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_dynamic);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
|
2011-06-29 04:16:02 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_force__load);
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_image__base);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_init);
|
|
|
|
|
2011-04-29 05:23:41 +08:00
|
|
|
// Add the deployment target.
|
|
|
|
unsigned TargetVersion[3];
|
|
|
|
DarwinTC.getTargetVersion(TargetVersion);
|
2011-04-30 12:22:58 +08:00
|
|
|
|
|
|
|
// If we had an explicit -mios-simulator-version-min argument, honor that,
|
|
|
|
// otherwise use the traditional deployment targets. We can't just check the
|
|
|
|
// is-sim attribute because existing code follows this path, and the linker
|
|
|
|
// may not handle the argument.
|
|
|
|
//
|
|
|
|
// FIXME: We may be able to remove this, once we can verify no one depends on
|
|
|
|
// it.
|
|
|
|
if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
|
|
|
|
CmdArgs.push_back("-ios_simulator_version_min");
|
|
|
|
else if (DarwinTC.isTargetIPhoneOS())
|
|
|
|
CmdArgs.push_back("-iphoneos_version_min");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-macosx_version_min");
|
2011-07-23 18:55:15 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(Twine(TargetVersion[0]) + "." +
|
|
|
|
Twine(TargetVersion[1]) + "." +
|
|
|
|
Twine(TargetVersion[2])));
|
2011-04-29 05:23:41 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_multi__module);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_single__module);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-07-14 07:31:40 +08:00
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
|
|
|
|
options::OPT_fno_pie,
|
|
|
|
options::OPT_fno_PIE)) {
|
|
|
|
if (A->getOption().matches(options::OPT_fpie) ||
|
|
|
|
A->getOption().matches(options::OPT_fPIE))
|
|
|
|
CmdArgs.push_back("-pie");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-no_pie");
|
|
|
|
}
|
2009-03-27 00:23:12 +08:00
|
|
|
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_prebind);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_noprebind);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segprot);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
|
2009-09-05 02:35:41 +08:00
|
|
|
|
2011-05-03 05:03:47 +08:00
|
|
|
// Give --sysroot= preference, over the Apple specific behavior to also use
|
|
|
|
// --isysroot as the syslibroot.
|
|
|
|
if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
|
|
|
|
CmdArgs.push_back("-syslibroot");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
} else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
|
|
|
|
CmdArgs.push_back("-syslibroot");
|
|
|
|
CmdArgs.push_back(A->getValue(Args));
|
|
|
|
} else if (getDarwinToolChain().isTargetIPhoneOS()) {
|
|
|
|
CmdArgs.push_back("-syslibroot");
|
|
|
|
CmdArgs.push_back("/Developer/SDKs/Extra");
|
2009-09-05 02:35:41 +08:00
|
|
|
}
|
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_undefined);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
|
2009-09-05 02:35:41 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_y);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_w);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_whyload);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_dylinker);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_Mach);
|
|
|
|
}
|
|
|
|
|
|
|
|
void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-03-27 00:23:12 +08:00
|
|
|
const char *LinkingOutput) const {
|
|
|
|
assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
|
2009-09-09 00:39:16 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
// The logic here is derived from gcc's behavior; most of which
|
|
|
|
// comes from specs (starting with link_command). Consult gcc for
|
|
|
|
// more information.
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
// I'm not sure why this particular decomposition exists in gcc, but
|
|
|
|
// we follow suite for ease of comparison.
|
2010-09-10 05:51:05 +08:00
|
|
|
AddLinkArgs(C, Args, CmdArgs);
|
2009-03-27 00:23:12 +08:00
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_s);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_t);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_A);
|
|
|
|
Args.AddLastArg(CmdArgs, options::OPT_e);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_r);
|
|
|
|
|
2010-10-19 06:08:36 +08:00
|
|
|
// Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
|
|
|
|
// members of static archive libraries which implement Objective-C classes or
|
|
|
|
// categories.
|
|
|
|
if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
|
|
|
|
CmdArgs.push_back("-ObjC");
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_A) &&
|
|
|
|
!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
// Derived from startfile spec.
|
|
|
|
if (Args.hasArg(options::OPT_dynamiclib)) {
|
2009-04-09 07:54:23 +08:00
|
|
|
// Derived from darwin_dylib1 spec.
|
2011-04-02 05:02:42 +08:00
|
|
|
if (getDarwinToolChain().isTargetIOSSimulator()) {
|
|
|
|
// The simulator doesn't have a versioned crt1 file.
|
|
|
|
CmdArgs.push_back("-ldylib1.o");
|
|
|
|
} else if (getDarwinToolChain().isTargetIPhoneOS()) {
|
2010-01-27 08:56:56 +08:00
|
|
|
if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
|
|
|
|
CmdArgs.push_back("-ldylib1.o");
|
|
|
|
} else {
|
2010-01-27 08:57:03 +08:00
|
|
|
if (getDarwinToolChain().isMacosxVersionLT(10, 5))
|
2010-01-27 08:56:56 +08:00
|
|
|
CmdArgs.push_back("-ldylib1.o");
|
2010-01-27 08:57:03 +08:00
|
|
|
else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
|
2010-01-27 08:56:56 +08:00
|
|
|
CmdArgs.push_back("-ldylib1.10.5.o");
|
|
|
|
}
|
2009-03-27 00:23:12 +08:00
|
|
|
} else {
|
|
|
|
if (Args.hasArg(options::OPT_bundle)) {
|
2009-04-01 11:17:40 +08:00
|
|
|
if (!Args.hasArg(options::OPT_static)) {
|
|
|
|
// Derived from darwin_bundle1 spec.
|
2011-04-02 05:02:42 +08:00
|
|
|
if (getDarwinToolChain().isTargetIOSSimulator()) {
|
|
|
|
// The simulator doesn't have a versioned crt1 file.
|
|
|
|
CmdArgs.push_back("-lbundle1.o");
|
|
|
|
} else if (getDarwinToolChain().isTargetIPhoneOS()) {
|
2010-01-27 08:56:56 +08:00
|
|
|
if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
|
|
|
|
CmdArgs.push_back("-lbundle1.o");
|
|
|
|
} else {
|
2010-01-27 08:57:03 +08:00
|
|
|
if (getDarwinToolChain().isMacosxVersionLT(10, 6))
|
2010-01-27 08:56:56 +08:00
|
|
|
CmdArgs.push_back("-lbundle1.o");
|
|
|
|
}
|
2009-04-01 11:17:40 +08:00
|
|
|
}
|
2009-03-27 00:23:12 +08:00
|
|
|
} else {
|
2011-03-02 02:49:30 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg) &&
|
|
|
|
getToolChain().SupportsProfiling()) {
|
2009-03-27 00:23:12 +08:00
|
|
|
if (Args.hasArg(options::OPT_static) ||
|
|
|
|
Args.hasArg(options::OPT_object) ||
|
|
|
|
Args.hasArg(options::OPT_preload)) {
|
|
|
|
CmdArgs.push_back("-lgcrt0.o");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-lgcrt1.o");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
// darwin_crt2 spec is empty.
|
2009-04-09 07:54:23 +08:00
|
|
|
}
|
2009-03-27 00:23:12 +08:00
|
|
|
} else {
|
|
|
|
if (Args.hasArg(options::OPT_static) ||
|
|
|
|
Args.hasArg(options::OPT_object) ||
|
|
|
|
Args.hasArg(options::OPT_preload)) {
|
|
|
|
CmdArgs.push_back("-lcrt0.o");
|
|
|
|
} else {
|
|
|
|
// Derived from darwin_crt1 spec.
|
2011-04-01 01:12:33 +08:00
|
|
|
if (getDarwinToolChain().isTargetIOSSimulator()) {
|
|
|
|
// The simulator doesn't have a versioned crt1 file.
|
|
|
|
CmdArgs.push_back("-lcrt1.o");
|
|
|
|
} else if (getDarwinToolChain().isTargetIPhoneOS()) {
|
2010-01-27 08:56:56 +08:00
|
|
|
if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
|
|
|
|
CmdArgs.push_back("-lcrt1.o");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lcrt1.3.1.o");
|
2010-01-27 08:57:03 +08:00
|
|
|
} else {
|
|
|
|
if (getDarwinToolChain().isMacosxVersionLT(10, 5))
|
|
|
|
CmdArgs.push_back("-lcrt1.o");
|
|
|
|
else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
|
|
|
|
CmdArgs.push_back("-lcrt1.10.5.o");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lcrt1.10.6.o");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-01-27 08:57:03 +08:00
|
|
|
// darwin_crt2 spec is empty.
|
|
|
|
}
|
2009-03-27 00:23:12 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-27 08:57:03 +08:00
|
|
|
if (!getDarwinToolChain().isTargetIPhoneOS() &&
|
|
|
|
Args.hasArg(options::OPT_shared_libgcc) &&
|
|
|
|
getDarwinToolChain().isMacosxVersionLT(10, 5)) {
|
2009-09-10 06:32:48 +08:00
|
|
|
const char *Str =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
|
2009-09-10 06:32:48 +08:00
|
|
|
CmdArgs.push_back(Str);
|
2009-03-27 00:23:12 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
if (Args.hasArg(options::OPT_fopenmp))
|
|
|
|
// This is more complicated in gcc...
|
|
|
|
CmdArgs.push_back("-lgomp");
|
|
|
|
|
2009-09-18 16:14:36 +08:00
|
|
|
getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
|
2011-06-16 07:02:42 +08:00
|
|
|
|
|
|
|
// In ARC, if we don't have runtime support, link in the runtime
|
|
|
|
// stubs. We have to do this *before* adding any of the normal
|
|
|
|
// linker inputs so that its initializer gets run first.
|
2011-07-06 08:26:06 +08:00
|
|
|
if (isObjCAutoRefCount(Args)) {
|
|
|
|
ObjCRuntime runtime;
|
|
|
|
getDarwinToolChain().configureObjCRuntime(runtime);
|
|
|
|
if (!runtime.HasARC)
|
|
|
|
getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2009-03-27 00:23:12 +08:00
|
|
|
|
|
|
|
if (LinkingOutput) {
|
|
|
|
CmdArgs.push_back("-arch_multiple");
|
|
|
|
CmdArgs.push_back("-final_output");
|
|
|
|
CmdArgs.push_back(LinkingOutput);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_fnested_functions))
|
|
|
|
CmdArgs.push_back("-allow_stack_execute");
|
2009-04-09 07:54:23 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
2009-12-22 02:54:17 +08:00
|
|
|
if (getToolChain().getDriver().CCCIsCXX)
|
2010-09-17 09:20:05 +08:00
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2009-04-08 14:06:21 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
// link_ssp spec is empty.
|
|
|
|
|
2009-09-18 16:15:03 +08:00
|
|
|
// Let the tool chain choose which runtime library to link.
|
|
|
|
getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
|
2009-03-27 00:23:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_A) &&
|
|
|
|
!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
// endfile_spec is empty.
|
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2009-03-27 00:23:12 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_F);
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("ld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-27 00:23:12 +08:00
|
|
|
}
|
|
|
|
|
2009-03-20 08:52:38 +08:00
|
|
|
void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-03-20 08:52:38 +08:00
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
CmdArgs.push_back("-create");
|
|
|
|
assert(Output.isFilename() && "Unexpected lipo output.");
|
2009-03-24 08:24:37 +08:00
|
|
|
|
|
|
|
CmdArgs.push_back("-output");
|
2009-03-20 08:52:38 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2009-03-24 08:24:37 +08:00
|
|
|
|
2009-03-20 08:52:38 +08:00
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
assert(II.isFilename() && "Unexpected lipo input.");
|
|
|
|
CmdArgs.push_back(II.getFilename());
|
|
|
|
}
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-03-20 08:52:38 +08:00
|
|
|
}
|
2009-04-01 01:45:15 +08:00
|
|
|
|
2010-06-05 02:28:36 +08:00
|
|
|
void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2010-06-05 02:28:36 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2011-05-10 01:23:16 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
2010-06-05 02:28:36 +08:00
|
|
|
assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
|
|
|
|
const InputInfo &Input = Inputs[0];
|
|
|
|
assert(Input.isFilename() && "Unexpected dsymutil input.");
|
|
|
|
CmdArgs.push_back(Input.getFilename());
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2010-06-05 02:28:36 +08:00
|
|
|
}
|
|
|
|
|
2011-08-24 01:56:55 +08:00
|
|
|
void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
CmdArgs.push_back("--verify");
|
|
|
|
|
|
|
|
assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
|
|
|
|
const InputInfo &Input = Inputs[0];
|
|
|
|
assert(Input.isFilename() && "Unexpected verify input");
|
|
|
|
|
|
|
|
// Grabbing the output of the earlier dsymutil run.
|
|
|
|
CmdArgs.push_back(Input.getFilename());
|
|
|
|
|
|
|
|
const char *Exec =
|
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
|
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
|
|
|
}
|
|
|
|
|
2009-08-22 09:06:46 +08:00
|
|
|
void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-11-04 14:24:38 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2009-08-22 09:06:46 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2009-08-22 09:06:46 +08:00
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("gas"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-11-04 14:24:38 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2009-08-22 09:06:46 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
if ((!Args.hasArg(options::OPT_nostdlib)) &&
|
2009-11-04 14:24:38 +08:00
|
|
|
(!Args.hasArg(options::OPT_shared))) {
|
2009-08-22 09:06:46 +08:00
|
|
|
CmdArgs.push_back("-e");
|
2009-10-15 15:44:07 +08:00
|
|
|
CmdArgs.push_back("_start");
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-Bstatic");
|
2009-10-15 15:44:07 +08:00
|
|
|
CmdArgs.push_back("-dn");
|
2009-08-22 09:06:46 +08:00
|
|
|
} else {
|
2009-10-15 15:44:07 +08:00
|
|
|
// CmdArgs.push_back("--eh-frame-hdr");
|
2009-08-22 09:06:46 +08:00
|
|
|
CmdArgs.push_back("-Bdynamic");
|
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-shared");
|
|
|
|
} else {
|
2009-10-17 03:44:18 +08:00
|
|
|
CmdArgs.push_back("--dynamic-linker");
|
2009-08-22 09:06:46 +08:00
|
|
|
CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2009-08-22 09:06:46 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared)) {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crt1.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crti.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtbegin.o")));
|
2009-08-22 09:06:46 +08:00
|
|
|
} else {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crti.o")));
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtn.o")));
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
2009-11-04 14:24:38 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
|
|
|
|
+ getToolChain().getTripleString()
|
2009-10-29 10:24:37 +08:00
|
|
|
+ "/4.2.4"));
|
2009-08-22 09:06:46 +08:00
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2009-08-22 09:06:46 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
|
|
|
// FIXME: For some reason GCC passes -lgcc before adding
|
|
|
|
// the default system libraries. Just mimic this for now.
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
|
|
|
CmdArgs.push_back("-pthread");
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtend.o")));
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2009-08-22 09:06:46 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("ld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-08-22 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
2009-06-30 04:52:51 +08:00
|
|
|
void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-06-30 04:52:51 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-09-09 23:08:12 +08:00
|
|
|
const char *LinkingOutput) const {
|
2009-06-30 04:52:51 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2009-06-30 04:52:51 +08:00
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("as"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-06-30 04:52:51 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-06-30 04:52:51 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2009-08-03 09:28:59 +08:00
|
|
|
if ((!Args.hasArg(options::OPT_nostdlib)) &&
|
2009-11-04 14:24:38 +08:00
|
|
|
(!Args.hasArg(options::OPT_shared))) {
|
2009-08-03 09:28:59 +08:00
|
|
|
CmdArgs.push_back("-e");
|
|
|
|
CmdArgs.push_back("__start");
|
|
|
|
}
|
|
|
|
|
2009-06-30 04:52:51 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-Bstatic");
|
|
|
|
} else {
|
2010-11-11 10:17:51 +08:00
|
|
|
if (Args.hasArg(options::OPT_rdynamic))
|
|
|
|
CmdArgs.push_back("-export-dynamic");
|
2009-06-30 04:52:51 +08:00
|
|
|
CmdArgs.push_back("--eh-frame-hdr");
|
2009-08-03 09:28:59 +08:00
|
|
|
CmdArgs.push_back("-Bdynamic");
|
2009-06-30 04:52:51 +08:00
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
2009-08-03 09:28:59 +08:00
|
|
|
CmdArgs.push_back("-shared");
|
2009-06-30 04:52:51 +08:00
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-dynamic-linker");
|
|
|
|
CmdArgs.push_back("/usr/libexec/ld.so");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2009-06-30 04:52:51 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared)) {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crt0.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtbegin.o")));
|
2009-06-30 04:52:51 +08:00
|
|
|
} else {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtbeginS.o")));
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-28 23:13:08 +08:00
|
|
|
std::string Triple = getToolChain().getTripleString();
|
|
|
|
if (Triple.substr(0, 6) == "x86_64")
|
2009-11-04 14:24:38 +08:00
|
|
|
Triple.replace(0, 6, "amd64");
|
2009-10-29 10:24:37 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
|
2010-08-02 07:13:54 +08:00
|
|
|
"/4.2.1"));
|
2009-08-03 09:28:59 +08:00
|
|
|
|
2009-06-30 04:52:51 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2009-06-30 04:52:51 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
2010-08-02 07:13:54 +08:00
|
|
|
if (D.CCCIsCXX) {
|
2010-09-17 09:20:05 +08:00
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2010-08-02 07:13:54 +08:00
|
|
|
CmdArgs.push_back("-lm");
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:28:59 +08:00
|
|
|
// FIXME: For some reason GCC passes -lgcc before adding
|
|
|
|
// the default system libraries. Just mimic this for now.
|
|
|
|
CmdArgs.push_back("-lgcc");
|
2009-06-30 04:52:51 +08:00
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
2011-02-22 02:36:51 +08:00
|
|
|
CmdArgs.push_back("-lpthread");
|
2009-08-03 09:28:59 +08:00
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
CmdArgs.push_back("-lgcc");
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtend.o")));
|
2009-06-30 04:52:51 +08:00
|
|
|
else
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtendS.o")));
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("ld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-06-30 04:52:51 +08:00
|
|
|
}
|
2009-04-03 03:13:12 +08:00
|
|
|
|
2009-04-01 01:45:15 +08:00
|
|
|
void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-09-09 23:08:12 +08:00
|
|
|
const char *LinkingOutput) const {
|
2009-04-01 01:45:15 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2009-04-02 03:36:32 +08:00
|
|
|
// When building 32-bit code on FreeBSD/amd64, we have to explicitly
|
|
|
|
// instruct as in the base system to assemble 32-bit code.
|
|
|
|
if (getToolChain().getArchName() == "i386")
|
2009-04-01 01:45:15 +08:00
|
|
|
CmdArgs.push_back("--32");
|
|
|
|
|
2011-06-04 15:37:31 +08:00
|
|
|
if (getToolChain().getArchName() == "powerpc")
|
|
|
|
CmdArgs.push_back("-a32");
|
2010-10-21 11:16:25 +08:00
|
|
|
|
2010-03-02 10:41:08 +08:00
|
|
|
// Set byte order explicitly
|
|
|
|
if (getToolChain().getArchName() == "mips")
|
|
|
|
CmdArgs.push_back("-EB");
|
|
|
|
else if (getToolChain().getArchName() == "mipsel")
|
|
|
|
CmdArgs.push_back("-EL");
|
|
|
|
|
2009-04-01 01:45:15 +08:00
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2009-04-01 01:45:15 +08:00
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-04-01 01:45:15 +08:00
|
|
|
}
|
|
|
|
|
2009-04-09 07:54:23 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("as"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-04-01 01:45:15 +08:00
|
|
|
}
|
2009-04-02 03:36:32 +08:00
|
|
|
|
|
|
|
void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-04-09 07:54:23 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
2009-05-03 04:14:53 +08:00
|
|
|
const char *LinkingOutput) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-04-02 03:36:32 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2011-03-21 21:51:29 +08:00
|
|
|
if (!D.SysRoot.empty())
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
|
|
|
|
|
2009-04-02 03:36:32 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-Bstatic");
|
|
|
|
} else {
|
2010-11-11 10:17:51 +08:00
|
|
|
if (Args.hasArg(options::OPT_rdynamic))
|
|
|
|
CmdArgs.push_back("-export-dynamic");
|
2009-04-02 03:36:32 +08:00
|
|
|
CmdArgs.push_back("--eh-frame-hdr");
|
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-Bshareable");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-dynamic-linker");
|
|
|
|
CmdArgs.push_back("/libexec/ld-elf.so.1");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// When building 32-bit code on FreeBSD/amd64, we have to explicitly
|
|
|
|
// instruct ld in the base system to link 32-bit code.
|
|
|
|
if (getToolChain().getArchName() == "i386") {
|
|
|
|
CmdArgs.push_back("-m");
|
|
|
|
CmdArgs.push_back("elf_i386_fbsd");
|
|
|
|
}
|
|
|
|
|
2011-06-04 15:40:24 +08:00
|
|
|
if (getToolChain().getArchName() == "powerpc") {
|
|
|
|
CmdArgs.push_back("-m");
|
|
|
|
CmdArgs.push_back("elf32ppc");
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2009-04-02 03:36:32 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared)) {
|
2011-02-11 00:59:40 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg))
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("gcrt1.o")));
|
|
|
|
else
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crt1.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crti.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtbegin.o")));
|
2009-04-02 03:36:32 +08:00
|
|
|
} else {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crti.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtbeginS.o")));
|
2009-04-02 03:36:32 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
2011-03-02 01:53:14 +08:00
|
|
|
const ToolChain::path_list Paths = getToolChain().getFilePaths();
|
|
|
|
for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
|
|
|
|
i != e; ++i)
|
2011-07-23 18:55:15 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
|
2009-04-02 03:36:32 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
2010-08-16 06:58:12 +08:00
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_s);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_t);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_r);
|
2009-04-02 03:36:32 +08:00
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2011-02-03 02:59:27 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
|
|
|
if (D.CCCIsCXX) {
|
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2011-02-11 00:59:40 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg))
|
|
|
|
CmdArgs.push_back("-lm_p");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lm");
|
2011-02-03 02:59:27 +08:00
|
|
|
}
|
|
|
|
// FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
|
|
|
|
// the default system libraries. Just mimic this for now.
|
2011-02-11 00:59:40 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg))
|
|
|
|
CmdArgs.push_back("-lgcc_p");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lgcc");
|
2011-02-03 02:59:27 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh");
|
2011-02-11 00:59:40 +08:00
|
|
|
} else if (Args.hasArg(options::OPT_pg)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh_p");
|
2011-02-03 02:59:27 +08:00
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
|
|
|
}
|
|
|
|
|
2011-02-11 04:35:01 +08:00
|
|
|
if (Args.hasArg(options::OPT_pthread)) {
|
2011-02-11 00:59:40 +08:00
|
|
|
if (Args.hasArg(options::OPT_pg))
|
|
|
|
CmdArgs.push_back("-lpthread_p");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lpthread");
|
2011-02-11 04:35:01 +08:00
|
|
|
}
|
2011-02-11 00:59:40 +08:00
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pg)) {
|
|
|
|
if (Args.hasArg(options::OPT_shared))
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-lc_p");
|
|
|
|
CmdArgs.push_back("-lgcc_p");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
}
|
2011-02-03 02:59:27 +08:00
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh");
|
2011-02-11 00:59:40 +08:00
|
|
|
} else if (Args.hasArg(options::OPT_pg)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh_p");
|
2011-02-03 02:59:27 +08:00
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
|
|
|
"crtend.o")));
|
|
|
|
else
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
|
|
|
"crtendS.o")));
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
|
|
|
"crtn.o")));
|
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2011-02-03 02:59:27 +08:00
|
|
|
const char *Exec =
|
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("ld"));
|
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
|
|
|
}
|
|
|
|
|
|
|
|
void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
// When building 32-bit code on NetBSD/amd64, we have to explicitly
|
|
|
|
// instruct as in the base system to assemble 32-bit code.
|
2011-05-16 21:35:02 +08:00
|
|
|
if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
|
|
|
|
getToolChain().getArch() == llvm::Triple::x86)
|
2011-02-03 02:59:27 +08:00
|
|
|
CmdArgs.push_back("--32");
|
|
|
|
|
|
|
|
|
|
|
|
// Set byte order explicitly
|
|
|
|
if (getToolChain().getArchName() == "mips")
|
|
|
|
CmdArgs.push_back("-EB");
|
|
|
|
else if (getToolChain().getArchName() == "mipsel")
|
|
|
|
CmdArgs.push_back("-EL");
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
CmdArgs.push_back(II.getFilename());
|
|
|
|
}
|
|
|
|
|
2011-03-21 22:01:40 +08:00
|
|
|
const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
|
2011-05-16 21:35:02 +08:00
|
|
|
ToolTriple.getTriple(),
|
|
|
|
"as"));
|
2011-02-03 02:59:27 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
|
|
|
}
|
|
|
|
|
|
|
|
void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
const Driver &D = getToolChain().getDriver();
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2011-03-21 21:51:29 +08:00
|
|
|
if (!D.SysRoot.empty())
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
|
|
|
|
|
2011-02-03 02:59:27 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-Bstatic");
|
|
|
|
} else {
|
|
|
|
if (Args.hasArg(options::OPT_rdynamic))
|
|
|
|
CmdArgs.push_back("-export-dynamic");
|
|
|
|
CmdArgs.push_back("--eh-frame-hdr");
|
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-Bshareable");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-dynamic-linker");
|
|
|
|
CmdArgs.push_back("/libexec/ld.elf_so");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// When building 32-bit code on NetBSD/amd64, we have to explicitly
|
|
|
|
// instruct ld in the base system to link 32-bit code.
|
2011-05-16 21:35:02 +08:00
|
|
|
if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
|
|
|
|
getToolChain().getArch() == llvm::Triple::x86) {
|
2011-02-03 02:59:27 +08:00
|
|
|
CmdArgs.push_back("-m");
|
|
|
|
CmdArgs.push_back("elf_i386");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Output.isFilename()) {
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crt0.o")));
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crti.o")));
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crtbegin.o")));
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crti.o")));
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
|
|
|
getToolChain().GetFilePath("crtbeginS.o")));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_s);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_t);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_r);
|
|
|
|
|
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2009-04-02 03:36:32 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
2010-02-17 16:07:51 +08:00
|
|
|
if (D.CCCIsCXX) {
|
2010-09-17 09:20:05 +08:00
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2010-02-17 16:07:51 +08:00
|
|
|
CmdArgs.push_back("-lm");
|
|
|
|
}
|
2009-04-02 03:36:32 +08:00
|
|
|
// FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
|
|
|
|
// the default system libraries. Just mimic this for now.
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
|
|
|
}
|
2011-06-08 07:39:17 +08:00
|
|
|
CmdArgs.push_back("-lgcc");
|
2009-04-02 03:36:32 +08:00
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
|
|
|
CmdArgs.push_back("-lpthread");
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-lgcc_eh");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
2010-07-15 02:46:23 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
2010-07-08 00:01:42 +08:00
|
|
|
"crtend.o")));
|
2009-04-02 03:36:32 +08:00
|
|
|
else
|
2010-07-15 02:46:23 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
2010-07-08 00:01:42 +08:00
|
|
|
"crtendS.o")));
|
2010-07-15 02:46:23 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
2010-07-08 00:01:42 +08:00
|
|
|
"crtn.o")));
|
2009-04-02 03:36:32 +08:00
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2011-03-21 22:01:40 +08:00
|
|
|
const char *Exec = Args.MakeArgString(FindTargetProgramPath(getToolChain(),
|
2011-05-16 21:35:02 +08:00
|
|
|
ToolTriple.getTriple(),
|
|
|
|
"ld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-04-02 03:36:32 +08:00
|
|
|
}
|
2009-05-03 02:28:39 +08:00
|
|
|
|
2010-08-10 08:25:48 +08:00
|
|
|
void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
// Add --32/--64 to make sure we get the format we want.
|
|
|
|
// This is incomplete
|
|
|
|
if (getToolChain().getArch() == llvm::Triple::x86) {
|
|
|
|
CmdArgs.push_back("--32");
|
|
|
|
} else if (getToolChain().getArch() == llvm::Triple::x86_64) {
|
|
|
|
CmdArgs.push_back("--64");
|
|
|
|
} else if (getToolChain().getArch() == llvm::Triple::arm) {
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef MArch = getToolChain().getArchName();
|
2010-08-10 08:25:48 +08:00
|
|
|
if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
|
|
|
|
CmdArgs.push_back("-mfpu=neon");
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
|
|
|
CmdArgs.push_back(II.getFilename());
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("as"));
|
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
|
|
|
}
|
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
const toolchains::Linux& ToolChain =
|
|
|
|
static_cast<const toolchains::Linux&>(getToolChain());
|
|
|
|
const Driver &D = ToolChain.getDriver();
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2010-11-16 02:28:16 +08:00
|
|
|
// Silence warning for "clang -g foo.o -o foo"
|
|
|
|
Args.ClaimAllArgs(options::OPT_g_Group);
|
2011-03-01 13:25:27 +08:00
|
|
|
// and "clang -emit-llvm foo.o -o foo"
|
|
|
|
Args.ClaimAllArgs(options::OPT_emit_llvm);
|
2010-11-18 04:37:10 +08:00
|
|
|
// and for "clang -g foo.o -o foo". Other warning options are already
|
|
|
|
// handled somewhere else.
|
|
|
|
Args.ClaimAllArgs(options::OPT_w);
|
2010-11-16 02:28:16 +08:00
|
|
|
|
2011-03-21 21:51:29 +08:00
|
|
|
if (!D.SysRoot.empty())
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-18 06:26:15 +08:00
|
|
|
if (Args.hasArg(options::OPT_pie))
|
|
|
|
CmdArgs.push_back("-pie");
|
|
|
|
|
2010-11-08 06:57:16 +08:00
|
|
|
if (Args.hasArg(options::OPT_rdynamic))
|
|
|
|
CmdArgs.push_back("-export-dynamic");
|
|
|
|
|
2010-11-12 03:34:42 +08:00
|
|
|
if (Args.hasArg(options::OPT_s))
|
|
|
|
CmdArgs.push_back("-s");
|
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
|
|
|
|
e = ToolChain.ExtraOpts.end();
|
|
|
|
i != e; ++i)
|
|
|
|
CmdArgs.push_back(i->c_str());
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("--eh-frame-hdr");
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdArgs.push_back("-m");
|
|
|
|
if (ToolChain.getArch() == llvm::Triple::x86)
|
|
|
|
CmdArgs.push_back("elf_i386");
|
2011-08-19 08:30:14 +08:00
|
|
|
else if (ToolChain.getArch() == llvm::Triple::arm
|
2011-03-07 03:11:49 +08:00
|
|
|
|| ToolChain.getArch() == llvm::Triple::thumb)
|
2010-11-08 04:14:31 +08:00
|
|
|
CmdArgs.push_back("armelf_linux_eabi");
|
2011-04-06 06:04:27 +08:00
|
|
|
else if (ToolChain.getArch() == llvm::Triple::ppc)
|
|
|
|
CmdArgs.push_back("elf32ppclinux");
|
|
|
|
else if (ToolChain.getArch() == llvm::Triple::ppc64)
|
|
|
|
CmdArgs.push_back("elf64ppc");
|
2010-11-08 04:14:31 +08:00
|
|
|
else
|
|
|
|
CmdArgs.push_back("elf_x86_64");
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
2011-03-07 03:11:49 +08:00
|
|
|
if (ToolChain.getArch() == llvm::Triple::arm
|
|
|
|
|| ToolChain.getArch() == llvm::Triple::thumb)
|
2010-11-08 04:14:31 +08:00
|
|
|
CmdArgs.push_back("-Bstatic");
|
|
|
|
else
|
|
|
|
CmdArgs.push_back("-static");
|
|
|
|
} else if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-shared");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ToolChain.getArch() == llvm::Triple::arm ||
|
2011-03-07 03:11:49 +08:00
|
|
|
ToolChain.getArch() == llvm::Triple::thumb ||
|
2010-11-08 04:14:31 +08:00
|
|
|
(!Args.hasArg(options::OPT_static) &&
|
|
|
|
!Args.hasArg(options::OPT_shared))) {
|
|
|
|
CmdArgs.push_back("-dynamic-linker");
|
|
|
|
if (ToolChain.getArch() == llvm::Triple::x86)
|
|
|
|
CmdArgs.push_back("/lib/ld-linux.so.2");
|
2011-03-07 03:11:49 +08:00
|
|
|
else if (ToolChain.getArch() == llvm::Triple::arm ||
|
|
|
|
ToolChain.getArch() == llvm::Triple::thumb)
|
2010-11-08 04:14:31 +08:00
|
|
|
CmdArgs.push_back("/lib/ld-linux.so.3");
|
2011-04-06 06:04:27 +08:00
|
|
|
else if (ToolChain.getArch() == llvm::Triple::ppc)
|
2011-04-12 05:15:37 +08:00
|
|
|
CmdArgs.push_back("/lib/ld.so.1");
|
2011-04-06 06:04:27 +08:00
|
|
|
else if (ToolChain.getArch() == llvm::Triple::ppc64)
|
2011-04-12 05:15:37 +08:00
|
|
|
CmdArgs.push_back("/lib64/ld64.so.1");
|
2010-11-08 04:14:31 +08:00
|
|
|
else
|
|
|
|
CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
|
2010-12-01 09:52:43 +08:00
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
2010-11-18 06:26:15 +08:00
|
|
|
const char *crt1 = NULL;
|
|
|
|
if (!Args.hasArg(options::OPT_shared)){
|
|
|
|
if (Args.hasArg(options::OPT_pie))
|
|
|
|
crt1 = "Scrt1.o";
|
|
|
|
else
|
|
|
|
crt1 = "crt1.o";
|
|
|
|
}
|
|
|
|
if (crt1)
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
const char *crtbegin;
|
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
crtbegin = "crtbeginT.o";
|
2010-11-18 06:26:15 +08:00
|
|
|
else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
|
2010-11-12 11:00:39 +08:00
|
|
|
crtbegin = "crtbeginS.o";
|
|
|
|
else
|
|
|
|
crtbegin = "crtbegin.o";
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
|
|
|
|
}
|
2010-11-08 04:14:31 +08:00
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
|
|
|
|
const ToolChain::path_list Paths = ToolChain.getFilePaths();
|
|
|
|
|
2011-03-02 01:53:14 +08:00
|
|
|
for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
|
|
|
|
i != e; ++i)
|
2011-07-23 18:55:15 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
|
2010-11-08 04:14:31 +08:00
|
|
|
|
|
|
|
AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
|
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) {
|
2010-11-08 04:14:31 +08:00
|
|
|
ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
|
|
|
|
CmdArgs.push_back("-lm");
|
|
|
|
}
|
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (!Args.hasArg(options::OPT_nostdlib)) {
|
2011-06-04 14:27:06 +08:00
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
CmdArgs.push_back("--start-group");
|
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
if (!D.CCCIsCXX)
|
2010-11-12 11:00:39 +08:00
|
|
|
CmdArgs.push_back("-lgcc");
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
if (D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
} else {
|
|
|
|
if (!D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
if (!D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
|
|
|
}
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
CmdArgs.push_back("-lgcc_eh");
|
|
|
|
else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("-lgcc");
|
2010-11-12 03:34:42 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_pthread) ||
|
|
|
|
Args.hasArg(options::OPT_pthreads))
|
|
|
|
CmdArgs.push_back("-lpthread");
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
CmdArgs.push_back("-lc");
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_static))
|
|
|
|
CmdArgs.push_back("--end-group");
|
|
|
|
else {
|
|
|
|
if (!D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("-lgcc");
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (!D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("--as-needed");
|
|
|
|
CmdArgs.push_back("-lgcc_s");
|
|
|
|
if (!D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("--no-as-needed");
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-12 11:00:39 +08:00
|
|
|
if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
}
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2010-11-18 06:26:15 +08:00
|
|
|
|
2010-12-01 09:52:43 +08:00
|
|
|
if (!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
const char *crtend;
|
|
|
|
if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
|
|
|
|
crtend = "crtendS.o";
|
|
|
|
else
|
|
|
|
crtend = "crtend.o";
|
2010-11-12 11:00:39 +08:00
|
|
|
|
2010-12-01 09:52:43 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
|
|
|
|
}
|
2010-11-12 11:00:39 +08:00
|
|
|
}
|
2010-11-08 04:14:31 +08:00
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
if (Args.hasArg(options::OPT_use_gold_plugin)) {
|
|
|
|
CmdArgs.push_back("-plugin");
|
|
|
|
std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
|
|
|
|
CmdArgs.push_back(Args.MakeArgString(Plugin));
|
|
|
|
}
|
|
|
|
|
|
|
|
C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
|
|
|
|
}
|
2010-08-10 08:25:48 +08:00
|
|
|
|
2010-07-08 00:01:42 +08:00
|
|
|
void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2010-07-08 00:01:42 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2010-07-08 00:01:42 +08:00
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2010-07-08 00:01:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("gas"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2010-07-08 00:01:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2010-07-08 00:01:42 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles))
|
2010-07-15 02:46:23 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
2010-07-08 00:01:42 +08:00
|
|
|
"/usr/gnu/lib/crtso.o")));
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2010-07-08 00:01:42 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
|
|
|
if (D.CCCIsCXX) {
|
2010-09-17 09:20:05 +08:00
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back("-lm");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
|
|
|
CmdArgs.push_back("-lpthread");
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
CmdArgs.push_back("-L/usr/gnu/lib");
|
|
|
|
// FIXME: fill in the correct search path for the final
|
|
|
|
// support libraries.
|
|
|
|
CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
2010-07-15 02:46:23 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
|
2010-07-08 00:01:42 +08:00
|
|
|
"/usr/gnu/lib/libend.a")));
|
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2010-07-08 00:01:42 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2010-07-08 00:01:42 +08:00
|
|
|
}
|
|
|
|
|
2009-05-03 02:28:39 +08:00
|
|
|
/// DragonFly Tools
|
|
|
|
|
|
|
|
// For now, DragonFly Assemble does just about the same as for
|
|
|
|
// FreeBSD, but this may change soon.
|
|
|
|
void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
2009-11-04 14:24:38 +08:00
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2009-05-03 02:28:39 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
// When building 32-bit code on DragonFly/pc64, we have to explicitly
|
|
|
|
// instruct as in the base system to assemble 32-bit code.
|
|
|
|
if (getToolChain().getArchName() == "i386")
|
|
|
|
CmdArgs.push_back("--32");
|
|
|
|
|
|
|
|
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
|
|
|
|
options::OPT_Xassembler);
|
|
|
|
|
|
|
|
CmdArgs.push_back("-o");
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(Output.getFilename());
|
2009-05-03 02:28:39 +08:00
|
|
|
|
|
|
|
for (InputInfoList::const_iterator
|
|
|
|
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
|
|
|
|
const InputInfo &II = *it;
|
2010-08-02 10:38:21 +08:00
|
|
|
CmdArgs.push_back(II.getFilename());
|
2009-05-03 02:28:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("as"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-05-03 02:28:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
2010-08-02 10:38:28 +08:00
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
2009-12-22 02:54:17 +08:00
|
|
|
const Driver &D = getToolChain().getDriver();
|
2009-05-03 02:28:39 +08:00
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
2011-03-21 21:51:29 +08:00
|
|
|
if (!D.SysRoot.empty())
|
|
|
|
CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
|
|
|
|
|
2009-05-03 02:28:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-Bstatic");
|
|
|
|
} else {
|
|
|
|
if (Args.hasArg(options::OPT_shared))
|
|
|
|
CmdArgs.push_back("-Bshareable");
|
|
|
|
else {
|
|
|
|
CmdArgs.push_back("-dynamic-linker");
|
|
|
|
CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// When building 32-bit code on DragonFly/pc64, we have to explicitly
|
|
|
|
// instruct ld in the base system to link 32-bit code.
|
|
|
|
if (getToolChain().getArchName() == "i386") {
|
|
|
|
CmdArgs.push_back("-m");
|
|
|
|
CmdArgs.push_back("elf_i386");
|
|
|
|
}
|
|
|
|
|
2010-08-02 10:38:21 +08:00
|
|
|
if (Output.isFilename()) {
|
2009-05-03 02:28:39 +08:00
|
|
|
CmdArgs.push_back("-o");
|
|
|
|
CmdArgs.push_back(Output.getFilename());
|
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared)) {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
|
2009-05-03 02:28:39 +08:00
|
|
|
} else {
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
|
2009-05-03 02:28:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_L);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
|
|
|
|
Args.AddAllArgs(CmdArgs, options::OPT_e);
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2009-05-03 02:28:39 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nodefaultlibs)) {
|
|
|
|
// FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
|
|
|
|
// rpaths
|
|
|
|
CmdArgs.push_back("-L/usr/lib/gcc41");
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_static)) {
|
|
|
|
CmdArgs.push_back("-rpath");
|
|
|
|
CmdArgs.push_back("/usr/lib/gcc41");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-rpath-link");
|
|
|
|
CmdArgs.push_back("/usr/lib/gcc41");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-rpath");
|
|
|
|
CmdArgs.push_back("/usr/lib");
|
|
|
|
|
|
|
|
CmdArgs.push_back("-rpath-link");
|
|
|
|
CmdArgs.push_back("/usr/lib");
|
|
|
|
}
|
|
|
|
|
2010-07-20 20:59:03 +08:00
|
|
|
if (D.CCCIsCXX) {
|
2010-09-17 09:20:05 +08:00
|
|
|
getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
|
2010-07-20 20:59:03 +08:00
|
|
|
CmdArgs.push_back("-lm");
|
|
|
|
}
|
|
|
|
|
2009-05-03 02:28:39 +08:00
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-lgcc_pic");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_pthread))
|
2009-11-01 04:11:46 +08:00
|
|
|
CmdArgs.push_back("-lpthread");
|
2009-05-03 02:28:39 +08:00
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nolibc)) {
|
|
|
|
CmdArgs.push_back("-lc");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Args.hasArg(options::OPT_shared)) {
|
|
|
|
CmdArgs.push_back("-lgcc_pic");
|
|
|
|
} else {
|
|
|
|
CmdArgs.push_back("-lgcc");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
if (!Args.hasArg(options::OPT_shared))
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtend.o")));
|
2009-05-03 02:28:39 +08:00
|
|
|
else
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtendS.o")));
|
2010-07-08 00:01:42 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(
|
2010-07-15 02:46:23 +08:00
|
|
|
getToolChain().GetFilePath("crtn.o")));
|
2009-05-03 02:28:39 +08:00
|
|
|
}
|
|
|
|
|
2011-06-28 03:15:03 +08:00
|
|
|
addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
|
2011-05-25 05:54:59 +08:00
|
|
|
|
2009-05-03 02:28:39 +08:00
|
|
|
const char *Exec =
|
2010-07-15 02:46:23 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("ld"));
|
2010-08-02 10:38:28 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
2009-05-03 02:28:39 +08:00
|
|
|
}
|
2010-08-22 05:55:07 +08:00
|
|
|
|
|
|
|
void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
|
|
|
|
const InputInfo &Output,
|
|
|
|
const InputInfoList &Inputs,
|
|
|
|
const ArgList &Args,
|
|
|
|
const char *LinkingOutput) const {
|
|
|
|
ArgStringList CmdArgs;
|
|
|
|
|
|
|
|
if (Output.isFilename()) {
|
2010-09-17 08:45:02 +08:00
|
|
|
CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
|
|
|
|
Output.getFilename()));
|
2010-08-22 05:55:07 +08:00
|
|
|
} else {
|
|
|
|
assert(Output.isNothing() && "Invalid output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Args.hasArg(options::OPT_nostdlib) &&
|
|
|
|
!Args.hasArg(options::OPT_nostartfiles)) {
|
|
|
|
CmdArgs.push_back("-defaultlib:libcmt");
|
|
|
|
}
|
|
|
|
|
|
|
|
CmdArgs.push_back("-nologo");
|
|
|
|
|
2010-09-17 08:24:54 +08:00
|
|
|
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
|
2010-08-22 05:55:07 +08:00
|
|
|
|
|
|
|
const char *Exec =
|
2010-09-17 08:24:54 +08:00
|
|
|
Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
|
2010-08-22 05:55:07 +08:00
|
|
|
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
|
|
|
|
}
|