summaryrefslogtreecommitdiffstats
path: root/tools/clang-cc/Options.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tools/clang-cc/Options.cpp')
-rw-r--r--tools/clang-cc/Options.cpp327
1 files changed, 134 insertions, 193 deletions
diff --git a/tools/clang-cc/Options.cpp b/tools/clang-cc/Options.cpp
index 584f957..a18598e 100644
--- a/tools/clang-cc/Options.cpp
+++ b/tools/clang-cc/Options.cpp
@@ -21,6 +21,7 @@
#include "clang/Frontend/DiagnosticOptions.h"
#include "clang/Frontend/FrontendOptions.h"
#include "clang/Frontend/HeaderSearchOptions.h"
+#include "clang/Frontend/LangStandard.h"
#include "clang/Frontend/PCHReader.h"
#include "clang/Frontend/PreprocessorOptions.h"
#include "clang/Frontend/PreprocessorOutputOptions.h"
@@ -81,7 +82,7 @@ static llvm::cl::opt<bool>
AnalyzeAll("analyzer-opt-analyze-headers",
llvm::cl::desc("Force the static analyzer to analyze "
"functions defined in header files"));
-
+
static llvm::cl::opt<bool>
AnalyzerDisplayProgress("analyzer-display-progress",
llvm::cl::desc("Emit verbose output about the analyzer's progress"));
@@ -93,7 +94,7 @@ AnalyzerExperimentalChecks("analyzer-experimental-checks",
static llvm::cl::opt<bool>
AnalyzerExperimentalInternalChecks("analyzer-experimental-internal-checks",
llvm::cl::desc("Use new default path-sensitive checks currently in testing"));
-
+
static llvm::cl::opt<std::string>
AnalyzeSpecificFunction("analyze-function",
llvm::cl::desc("Run analysis on specific function"));
@@ -141,6 +142,46 @@ GenerateDebugInfo("g",
llvm::cl::desc("Generate source level debug information"));
static llvm::cl::opt<bool>
+MAsmVerbose("masm-verbose", llvm::cl::desc("Generate verbose assembly output"));
+
+static llvm::cl::opt<std::string>
+MCodeModel("mcode-model", llvm::cl::desc("The code model to use"));
+
+static llvm::cl::opt<std::string>
+MDebugPass("mdebu-pass", llvm::cl::desc("Output additional debug information"));
+
+static llvm::cl::opt<bool>
+MDisableFPElim("mdisable-fp-elim",
+ llvm::cl::desc("Disable frame pointer elimination optimization"));
+
+static llvm::cl::opt<std::string>
+MFloatABI("mfloat-abi", llvm::cl::desc("The float ABI to use"));
+
+static llvm::cl::opt<std::string>
+MLimitFloatPrecision("mlimit-float-precision",
+ llvm::cl::desc("Limit float precision to the given value"));
+
+static llvm::cl::opt<bool>
+MNoZeroInitializedInBSS("mno-zero-initialized-in-bss",
+ llvm::cl::desc("Do not put zero initialized data in the BSS"));
+
+static llvm::cl::opt<bool>
+MSoftFloat("msoft-float", llvm::cl::desc("Use software floating point"));
+
+static llvm::cl::opt<std::string>
+MRelocationModel("mrelocation-model",
+ llvm::cl::desc("The relocation model to use"),
+ llvm::cl::init("pic"));
+
+static llvm::cl::opt<bool>
+MUnwindTables("munwind-tables",
+ llvm::cl::desc("Generate unwinding tables for all functions"));
+
+static llvm::cl::opt<std::string>
+MainFileName("main-file-name",
+ llvm::cl::desc("Main file name to use for debug info"));
+
+static llvm::cl::opt<bool>
NoCommon("fno-common",
llvm::cl::desc("Compile common globals like normal definitions"),
llvm::cl::ValueDisallowed);
@@ -436,6 +477,8 @@ TimeReport("ftime-report",
namespace langoptions {
+using namespace clang::frontend;
+
static llvm::cl::opt<bool>
NoBuiltin("fno-builtin",
llvm::cl::desc("Disable implicit builtin knowledge of functions"));
@@ -448,8 +491,8 @@ AccessControl("faccess-control",
llvm::cl::desc("Enable C++ access control"));
static llvm::cl::opt<bool>
-CharIsSigned("fsigned-char",
- llvm::cl::desc("Force char to be a signed/unsigned type"));
+NoSignedChar("fno-signed-char",
+ llvm::cl::desc("Char is unsigned"));
static llvm::cl::opt<bool>
DollarsInIdents("fdollars-in-identifiers",
@@ -481,42 +524,12 @@ GNURuntime("fgnu-runtime",
llvm::cl::desc("Generate output compatible with the standard GNU "
"Objective-C runtime"));
-/// LangStds - Language standards we support.
-enum LangStds {
- lang_unspecified,
- lang_c89, lang_c94, lang_c99,
- lang_gnu89, lang_gnu99,
- lang_cxx98, lang_gnucxx98,
- lang_cxx0x, lang_gnucxx0x
-};
-static llvm::cl::opt<LangStds>
+static llvm::cl::opt<LangStandard::Kind>
LangStd("std", llvm::cl::desc("Language standard to compile for"),
- llvm::cl::init(lang_unspecified),
- llvm::cl::values(clEnumValN(lang_c89, "c89", "ISO C 1990"),
- clEnumValN(lang_c89, "c90", "ISO C 1990"),
- clEnumValN(lang_c89, "iso9899:1990", "ISO C 1990"),
- clEnumValN(lang_c94, "iso9899:199409",
- "ISO C 1990 with amendment 1"),
- clEnumValN(lang_c99, "c99", "ISO C 1999"),
- clEnumValN(lang_c99, "c9x", "ISO C 1999"),
- clEnumValN(lang_c99, "iso9899:1999", "ISO C 1999"),
- clEnumValN(lang_c99, "iso9899:199x", "ISO C 1999"),
- clEnumValN(lang_gnu89, "gnu89",
- "ISO C 1990 with GNU extensions"),
- clEnumValN(lang_gnu99, "gnu99",
- "ISO C 1999 with GNU extensions (default for C)"),
- clEnumValN(lang_gnu99, "gnu9x",
- "ISO C 1999 with GNU extensions"),
- clEnumValN(lang_cxx98, "c++98",
- "ISO C++ 1998 with amendments"),
- clEnumValN(lang_gnucxx98, "gnu++98",
- "ISO C++ 1998 with amendments and GNU "
- "extensions (default for C++)"),
- clEnumValN(lang_cxx0x, "c++0x",
- "Upcoming ISO C++ 200x with amendments"),
- clEnumValN(lang_gnucxx0x, "gnu++0x",
- "Upcoming ISO C++ 200x with amendments and GNU "
- "extensions"),
+ llvm::cl::init(LangStandard::lang_unspecified), llvm::cl::values(
+#define LANGSTANDARD(id, name, desc, features) \
+ clEnumValN(LangStandard::lang_##id, name, desc),
+#include "clang/Frontend/LangStandards.def"
clEnumValEnd));
static llvm::cl::opt<bool>
@@ -524,10 +537,6 @@ MSExtensions("fms-extensions",
llvm::cl::desc("Accept some non-standard constructs used in "
"Microsoft header files "));
-static llvm::cl::opt<std::string>
-MainFileName("main-file-name",
- llvm::cl::desc("Main file name to use for debug info"));
-
static llvm::cl::opt<bool>
NoMathErrno("fno-math-errno",
llvm::cl::desc("Don't require math functions to respect errno"));
@@ -745,6 +754,7 @@ DumpDefines("dD", llvm::cl::desc("Print macro definitions in -E mode in "
"addition to normal output"));
}
+
//===----------------------------------------------------------------------===//
// Target Options
//===----------------------------------------------------------------------===//
@@ -757,7 +767,7 @@ TargetABI("target-abi",
static llvm::cl::opt<std::string>
TargetCPU("mcpu",
- llvm::cl::desc("Target a specific cpu type (-mcpu=help for details)"));
+ llvm::cl::desc("Target a specific cpu type ('-mcpu help' for details)"));
static llvm::cl::list<std::string>
TargetFeatures("target-feature", llvm::cl::desc("Target specific attributes"));
@@ -791,8 +801,7 @@ void clang::InitializeAnalyzerOptions(AnalyzerOptions &Opts) {
}
void clang::InitializeCodeGenOptions(CodeGenOptions &Opts,
- const LangOptions &Lang,
- bool TimePasses) {
+ const LangOptions &Lang) {
using namespace codegenoptions;
// -Os implies -O2
@@ -810,19 +819,27 @@ void clang::InitializeCodeGenOptions(CodeGenOptions &Opts,
Opts.NoCommon = NoCommon;
Opts.NoImplicitFloat = NoImplicitFloat;
Opts.OptimizeSize = OptSize;
- Opts.SimplifyLibCalls = 1;
Opts.UnrollLoops = (Opts.OptimizationLevel > 1 && !OptSize);
- // FIXME: Eliminate this dependency?
- if (Lang.NoBuiltin)
- Opts.SimplifyLibCalls = 0;
- if (Lang.CPlusPlus)
- Opts.NoCommon = 1;
- Opts.TimePasses = TimePasses;
+ // LLVM Code Generator options.
+
+ Opts.AsmVerbose = MAsmVerbose;
+ Opts.CodeModel = MCodeModel;
+ Opts.DebugPass = MDebugPass;
+ Opts.DisableFPElim = MDisableFPElim;
+ Opts.FloatABI = MFloatABI;
+ Opts.LimitFloatPrecision = MLimitFloatPrecision;
+ Opts.NoZeroInitializedInBSS = MNoZeroInitializedInBSS;
+ Opts.SoftFloat = MSoftFloat;
+ Opts.RelocationModel = MRelocationModel;
+ Opts.UnwindTables = MUnwindTables;
#ifdef NDEBUG
Opts.VerifyModule = 0;
#endif
+
+ if (MainFileName.getPosition())
+ Opts.MainFileName = MainFileName;
}
void clang::InitializeDependencyOutputOptions(DependencyOutputOptions &Opts) {
@@ -857,13 +874,8 @@ void clang::InitializeDiagnosticOptions(DiagnosticOptions &Opts) {
void clang::InitializeFrontendOptions(FrontendOptions &Opts) {
using namespace frontendoptions;
- // Select program action.
Opts.ProgramAction = ProgAction;
- if (PluginActionName.getPosition()) {
- Opts.ProgramAction = frontend::PluginAction;
- Opts.ActionName = PluginActionName;
- }
-
+ Opts.ActionName = PluginActionName;
Opts.CodeCompletionAt = CodeCompletionAt;
Opts.DebugCodeCompletionPrinter = !NoCodeCompletionDebugPrinter;
Opts.DisableFree = DisableFree;
@@ -876,6 +888,14 @@ void clang::InitializeFrontendOptions(FrontendOptions &Opts) {
Opts.ShowTimers = TimeReport;
Opts.ViewClassInheritance = InheritanceViewCls;
+ // Enforce certain program action implications.
+ if (!Opts.ActionName.empty())
+ Opts.ProgramAction = frontend::PluginAction;
+ if (!Opts.ViewClassInheritance.empty())
+ Opts.ProgramAction = frontend::InheritanceView;
+ if (!Opts.FixItLocations.empty())
+ Opts.ProgramAction = frontend::FixIt;
+
// '-' is the default input if none is given.
if (InputFilenames.empty()) {
FrontendOptions::InputKind IK = InputType;
@@ -1054,145 +1074,87 @@ void clang::InitializePreprocessorOptions(PreprocessorOptions &Opts) {
}
void clang::InitializeLangOptions(LangOptions &Options,
- FrontendOptions::InputKind IK,
- TargetInfo &Target) {
+ FrontendOptions::InputKind IK) {
using namespace langoptions;
-
- switch (IK) {
- case FrontendOptions::IK_None:
- case FrontendOptions::IK_AST:
- assert(0 && "Invalid input kind!");
- case FrontendOptions::IK_Asm:
+ // Set some properties which depend soley on the input kind; it would be nice
+ // to move these to the language standard, and have the driver resolve the
+ // input kind + language standard.
+ if (IK == FrontendOptions::IK_Asm) {
Options.AsmPreprocessor = 1;
- // FALLTHROUGH
- case FrontendOptions::IK_PreprocessedC:
- // FALLTHROUGH
- case FrontendOptions::IK_C:
- // Do nothing.
- break;
- case FrontendOptions::IK_PreprocessedCXX:
- // FALLTHROUGH
- case FrontendOptions::IK_CXX:
- Options.CPlusPlus = 1;
- break;
- case FrontendOptions::IK_PreprocessedObjC:
- // FALLTHROUGH
- case FrontendOptions::IK_ObjC:
+ } else if (IK == FrontendOptions::IK_ObjC ||
+ IK == FrontendOptions::IK_ObjCXX ||
+ IK == FrontendOptions::IK_PreprocessedObjC ||
+ IK == FrontendOptions::IK_PreprocessedObjCXX) {
Options.ObjC1 = Options.ObjC2 = 1;
- break;
- case FrontendOptions::IK_PreprocessedObjCXX:
- // FALLTHROUGH
- case FrontendOptions::IK_ObjCXX:
- Options.ObjC1 = Options.ObjC2 = 1;
- Options.CPlusPlus = 1;
- break;
- case FrontendOptions::IK_OpenCL:
- Options.OpenCL = 1;
- Options.AltiVec = 1;
- Options.CXXOperatorNames = 1;
- Options.LaxVectorConversions = 1;
- break;
}
- if (ObjCExclusiveGC)
- Options.setGCMode(LangOptions::GCOnly);
- else if (ObjCEnableGC)
- Options.setGCMode(LangOptions::HybridGC);
-
- if (ObjCEnableGCBitmapPrint)
- Options.ObjCGCBitmapPrint = 1;
-
- if (AltiVec)
- Options.AltiVec = 1;
-
- if (PThread)
- Options.POSIXThreads = 1;
-
- Options.setVisibilityMode(SymbolVisibility);
- Options.OverflowChecking = OverflowChecking;
-
- if (LangStd == lang_unspecified) {
+ if (LangStd == LangStandard::lang_unspecified) {
// Based on the base language, pick one.
switch (IK) {
case FrontendOptions::IK_None:
case FrontendOptions::IK_AST:
assert(0 && "Invalid input kind!");
case FrontendOptions::IK_OpenCL:
- LangStd = lang_c99;
+ LangStd = LangStandard::lang_opencl;
break;
case FrontendOptions::IK_Asm:
case FrontendOptions::IK_C:
case FrontendOptions::IK_PreprocessedC:
case FrontendOptions::IK_ObjC:
case FrontendOptions::IK_PreprocessedObjC:
- LangStd = lang_gnu99;
+ LangStd = LangStandard::lang_gnu99;
break;
case FrontendOptions::IK_CXX:
case FrontendOptions::IK_PreprocessedCXX:
case FrontendOptions::IK_ObjCXX:
case FrontendOptions::IK_PreprocessedObjCXX:
- LangStd = lang_gnucxx98;
+ LangStd = LangStandard::lang_gnucxx98;
break;
}
}
- switch (LangStd) {
- default: assert(0 && "Unknown language standard!");
-
- // Fall through from newer standards to older ones. This isn't really right.
- // FIXME: Enable specifically the right features based on the language stds.
- case lang_gnucxx0x:
- case lang_cxx0x:
- Options.CPlusPlus0x = 1;
- // FALL THROUGH
- case lang_gnucxx98:
- case lang_cxx98:
- Options.CPlusPlus = 1;
- Options.CXXOperatorNames = !NoOperatorNames;
- // FALL THROUGH.
- case lang_gnu99:
- case lang_c99:
- Options.C99 = 1;
- Options.HexFloats = 1;
- // FALL THROUGH.
- case lang_gnu89:
- Options.BCPLComment = 1; // Only for C99/C++.
- // FALL THROUGH.
- case lang_c94:
- Options.Digraphs = 1; // C94, C99, C++.
- // FALL THROUGH.
- case lang_c89:
- break;
+ const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
+ Options.BCPLComment = Std.hasBCPLComments();
+ Options.C99 = Std.isC99();
+ Options.CPlusPlus = Std.isCPlusPlus();
+ Options.CPlusPlus0x = Std.isCPlusPlus0x();
+ Options.Digraphs = Std.hasDigraphs();
+ Options.GNUInline = !Std.isC99();
+ Options.GNUMode = Std.isGNUMode();
+ Options.HexFloats = Std.hasHexFloats();
+ Options.ImplicitInt = Std.hasImplicitInt();
+
+ // OpenCL has some additional defaults.
+ if (LangStd == LangStandard::lang_opencl) {
+ Options.OpenCL = 1;
+ Options.AltiVec = 1;
+ Options.CXXOperatorNames = 1;
+ Options.LaxVectorConversions = 1;
}
- // GNUMode - Set if we're in gnu99, gnu89, gnucxx98, etc.
- switch (LangStd) {
- default: assert(0 && "Unknown language standard!");
- case lang_gnucxx0x:
- case lang_gnucxx98:
- case lang_gnu99:
- case lang_gnu89:
- Options.GNUMode = 1;
- break;
- case lang_cxx0x:
- case lang_cxx98:
- case lang_c99:
- case lang_c94:
- case lang_c89:
- Options.GNUMode = 0;
- break;
- }
+ // OpenCL and C++ both have bool, true, false keywords.
+ Options.Bool = Options.OpenCL || Options.CPlusPlus;
- if (Options.CPlusPlus) {
- Options.C99 = 0;
- Options.HexFloats = 0;
- }
+ if (Options.CPlusPlus)
+ Options.CXXOperatorNames = !NoOperatorNames;
- if (LangStd == lang_c89 || LangStd == lang_c94 || LangStd == lang_gnu89)
- Options.ImplicitInt = 1;
- else
- Options.ImplicitInt = 0;
+ if (ObjCExclusiveGC)
+ Options.setGCMode(LangOptions::GCOnly);
+ else if (ObjCEnableGC)
+ Options.setGCMode(LangOptions::HybridGC);
+
+ if (ObjCEnableGCBitmapPrint)
+ Options.ObjCGCBitmapPrint = 1;
+
+ if (AltiVec)
+ Options.AltiVec = 1;
+
+ if (PThread)
+ Options.POSIXThreads = 1;
+
+ Options.setVisibilityMode(SymbolVisibility);
+ Options.OverflowChecking = OverflowChecking;
// Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
// is specified, or -std is set to a conforming mode.
@@ -1200,17 +1162,8 @@ void clang::InitializeLangOptions(LangOptions &Options,
if (Trigraphs.getPosition())
Options.Trigraphs = Trigraphs; // Command line option wins if specified.
- // If in a conformant language mode (e.g. -std=c99) Blocks defaults to off
- // even if they are normally on for the target. In GNU modes (e.g.
- // -std=gnu99) the default for blocks depends on the target settings.
- // However, blocks are not turned off when compiling Obj-C or Obj-C++ code.
- if (!Options.ObjC1 && !Options.GNUMode)
- Options.Blocks = 0;
-
- // Default to not accepting '$' in identifiers when preprocessing assembler,
- // but do accept when preprocessing C. FIXME: these defaults are right for
- // darwin, are they right everywhere?
- Options.DollarIdents = IK != FrontendOptions::IK_Asm;
+ // Default to not accepting '$' in identifiers when preprocessing assembler.
+ Options.DollarIdents = !Options.AsmPreprocessor;
if (DollarsInIdents.getPosition()) // Explicit setting overrides default.
Options.DollarIdents = DollarsInIdents;
@@ -1223,10 +1176,8 @@ void clang::InitializeLangOptions(LangOptions &Options,
Options.LaxVectorConversions = 0;
Options.Exceptions = Exceptions;
Options.Rtti = !NoRtti;
- if (EnableBlocks.getPosition())
- Options.Blocks = EnableBlocks;
- if (CharIsSigned.getPosition())
- Options.CharIsSigned = CharIsSigned;
+ Options.Blocks = EnableBlocks;
+ Options.CharIsSigned = !NoSignedChar;
if (ShortWChar.getPosition())
Options.ShortWChar = ShortWChar;
@@ -1242,9 +1193,6 @@ void clang::InitializeLangOptions(LangOptions &Options,
Options.ElideConstructors = !NoElideConstructors;
- // OpenCL and C++ both have bool, true, false keywords.
- Options.Bool = Options.OpenCL | Options.CPlusPlus;
-
Options.MathErrno = !NoMathErrno;
if (TemplateDepth.getPosition())
@@ -1255,7 +1203,7 @@ void clang::InitializeLangOptions(LangOptions &Options,
Options.NeXTRuntime = 0;
if (!ObjCConstantStringClass.empty())
- Options.ObjCConstantStringClass = ObjCConstantStringClass.c_str();
+ Options.ObjCConstantStringClass = ObjCConstantStringClass;
if (ObjCNonFragileABI)
Options.ObjCNonFragileABI = 1;
@@ -1272,8 +1220,6 @@ void clang::InitializeLangOptions(LangOptions &Options,
assert(PICLevel <= 2 && "Invalid value for -pic-level");
Options.PICLevel = PICLevel;
- Options.GNUInline = !Options.C99;
-
// This is the __NO_INLINE__ define, which just depends on things like the
// optimization level and -fno-inline, not actually whether the backend has
// inlining enabled.
@@ -1292,11 +1238,6 @@ void clang::InitializeLangOptions(LangOptions &Options,
case 2: Options.setStackProtectorMode(LangOptions::SSPReq); break;
}
}
-
- if (MainFileName.getPosition())
- Options.setMainFileName(MainFileName.c_str());
-
- Target.setForcedLangOptions(Options);
}
void
OpenPOWER on IntegriCloud