diff options
| author | dim <dim@FreeBSD.org> | 2013-12-22 00:07:40 +0000 |
|---|---|---|
| committer | dim <dim@FreeBSD.org> | 2013-12-22 00:07:40 +0000 |
| commit | 952eddef9aff85b1e92626e89baaf7a360e2ac85 (patch) | |
| tree | df8df0b0067b381eab470a3b8f28d14a552a6340 /include/clang/Driver | |
| parent | ea266cad53e3d49771fa38103913d3ec7a166694 (diff) | |
| download | FreeBSD-src-952eddef9aff85b1e92626e89baaf7a360e2ac85.zip FreeBSD-src-952eddef9aff85b1e92626e89baaf7a360e2ac85.tar.gz | |
Vendor import of clang release_34 branch r197841 (effectively, 3.4 RC3):
https://llvm.org/svn/llvm-project/cfe/branches/release_34@197841
Diffstat (limited to 'include/clang/Driver')
25 files changed, 1117 insertions, 1413 deletions
diff --git a/include/clang/Driver/Action.h b/include/clang/Driver/Action.h index 4057e48..289dbe3 100644 --- a/include/clang/Driver/Action.h +++ b/include/clang/Driver/Action.h @@ -14,9 +14,14 @@ #include "clang/Driver/Util.h" #include "llvm/ADT/SmallVector.h" +namespace llvm { +namespace opt { + class Arg; +} +} + namespace clang { namespace driver { - class Arg; /// Action - Represent an abstract compilation step to perform. /// @@ -94,11 +99,12 @@ public: class InputAction : public Action { virtual void anchor(); - const Arg &Input; + const llvm::opt::Arg &Input; + public: - InputAction(const Arg &_Input, types::ID _Type); + InputAction(const llvm::opt::Arg &_Input, types::ID _Type); - const Arg &getInputArg() const { return Input; } + const llvm::opt::Arg &getInputArg() const { return Input; } static bool classof(const Action *A) { return A->getKind() == InputClass; diff --git a/include/clang/Driver/Arg.h b/include/clang/Driver/Arg.h deleted file mode 100644 index 662a2e2..0000000 --- a/include/clang/Driver/Arg.h +++ /dev/null @@ -1,133 +0,0 @@ -//===--- Arg.h - Parsed Argument Classes ------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -/// -/// \file -/// \brief Defines the clang::driver::Arg class for parsed arguments. -/// -//===----------------------------------------------------------------------===// - -#ifndef CLANG_DRIVER_ARG_H_ -#define CLANG_DRIVER_ARG_H_ - -#include "Util.h" -#include "clang/Driver/Option.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include <string> - -namespace clang { -namespace driver { - class ArgList; - - /// \brief A concrete instance of a particular driver option. - /// - /// The Arg class encodes just enough information to be able to - /// derive the argument values efficiently. In addition, Arg - /// instances have an intrusive double linked list which is used by - /// ArgList to provide efficient iteration over all instances of a - /// particular option. - class Arg { - Arg(const Arg &) LLVM_DELETED_FUNCTION; - void operator=(const Arg &) LLVM_DELETED_FUNCTION; - - private: - /// \brief The option this argument is an instance of. - const Option Opt; - - /// \brief The argument this argument was derived from (during tool chain - /// argument translation), if any. - const Arg *BaseArg; - - /// \brief How this instance of the option was spelled. - StringRef Spelling; - - /// \brief The index at which this argument appears in the containing - /// ArgList. - unsigned Index; - - /// \brief Was this argument used to affect compilation? - /// - /// This is used for generating "argument unused" diagnostics. - mutable unsigned Claimed : 1; - - /// \brief Does this argument own its values? - mutable unsigned OwnsValues : 1; - - /// \brief The argument values, as C strings. - SmallVector<const char *, 2> Values; - - public: - Arg(const Option Opt, StringRef Spelling, unsigned Index, - const Arg *BaseArg = 0); - Arg(const Option Opt, StringRef Spelling, unsigned Index, - const char *Value0, const Arg *BaseArg = 0); - Arg(const Option Opt, StringRef Spelling, unsigned Index, - const char *Value0, const char *Value1, const Arg *BaseArg = 0); - ~Arg(); - - Option getOption() const { return Opt; } - StringRef getSpelling() const { return Spelling; } - unsigned getIndex() const { return Index; } - - /// \brief Return the base argument which generated this arg. - /// - /// This is either the argument itself or the argument it was - /// derived from during tool chain specific argument translation. - const Arg &getBaseArg() const { - return BaseArg ? *BaseArg : *this; - } - void setBaseArg(const Arg *_BaseArg) { - BaseArg = _BaseArg; - } - - bool getOwnsValues() const { return OwnsValues; } - void setOwnsValues(bool Value) const { OwnsValues = Value; } - - bool isClaimed() const { return getBaseArg().Claimed; } - - /// \brief Set the Arg claimed bit. - void claim() const { getBaseArg().Claimed = true; } - - unsigned getNumValues() const { return Values.size(); } - const char *getValue(unsigned N = 0) const { - return Values[N]; - } - - SmallVectorImpl<const char*> &getValues() { - return Values; - } - - bool containsValue(StringRef Value) const { - for (unsigned i = 0, e = getNumValues(); i != e; ++i) - if (Values[i] == Value) - return true; - return false; - } - - /// \brief Append the argument onto the given array as strings. - void render(const ArgList &Args, ArgStringList &Output) const; - - /// \brief Append the argument, render as an input, onto the given - /// array as strings. - /// - /// The distinction is that some options only render their values - /// when rendered as a input (e.g., Xlinker). - void renderAsInput(const ArgList &Args, ArgStringList &Output) const; - - void dump() const; - - /// \brief Return a formatted version of the argument and - /// its values, for debugging and diagnostics. - std::string getAsString(const ArgList &Args) const; - }; - -} // end namespace driver -} // end namespace clang - -#endif diff --git a/include/clang/Driver/ArgList.h b/include/clang/Driver/ArgList.h deleted file mode 100644 index 9db170c..0000000 --- a/include/clang/Driver/ArgList.h +++ /dev/null @@ -1,442 +0,0 @@ -//===--- ArgList.h - Argument List Management ----------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef CLANG_DRIVER_ARGLIST_H_ -#define CLANG_DRIVER_ARGLIST_H_ - -#include "clang/Basic/LLVM.h" -#include "clang/Driver/OptSpecifier.h" -#include "clang/Driver/Option.h" -#include "clang/Driver/Util.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include <list> -#include <string> -#include <vector> - -namespace clang { - class DiagnosticsEngine; - -namespace driver { - class Arg; - class ArgList; - class Option; - - /// arg_iterator - Iterates through arguments stored inside an ArgList. - class arg_iterator { - /// The current argument. - SmallVectorImpl<Arg*>::const_iterator Current; - - /// The argument list we are iterating over. - const ArgList &Args; - - /// Optional filters on the arguments which will be match. Most clients - /// should never want to iterate over arguments without filters, so we won't - /// bother to factor this into two separate iterator implementations. - // - // FIXME: Make efficient; the idea is to provide efficient iteration over - // all arguments which match a particular id and then just provide an - // iterator combinator which takes multiple iterators which can be - // efficiently compared and returns them in order. - OptSpecifier Id0, Id1, Id2; - - void SkipToNextArg(); - - public: - typedef Arg * const * value_type; - typedef Arg * const & reference; - typedef Arg * const * pointer; - typedef std::forward_iterator_tag iterator_category; - typedef std::ptrdiff_t difference_type; - - arg_iterator(SmallVectorImpl<Arg*>::const_iterator it, - const ArgList &_Args, OptSpecifier _Id0 = 0U, - OptSpecifier _Id1 = 0U, OptSpecifier _Id2 = 0U) - : Current(it), Args(_Args), Id0(_Id0), Id1(_Id1), Id2(_Id2) { - SkipToNextArg(); - } - - operator const Arg*() { return *Current; } - reference operator*() const { return *Current; } - pointer operator->() const { return Current; } - - arg_iterator &operator++() { - ++Current; - SkipToNextArg(); - return *this; - } - - arg_iterator operator++(int) { - arg_iterator tmp(*this); - ++(*this); - return tmp; - } - - friend bool operator==(arg_iterator LHS, arg_iterator RHS) { - return LHS.Current == RHS.Current; - } - friend bool operator!=(arg_iterator LHS, arg_iterator RHS) { - return !(LHS == RHS); - } - }; - - /// ArgList - Ordered collection of driver arguments. - /// - /// The ArgList class manages a list of Arg instances as well as - /// auxiliary data and convenience methods to allow Tools to quickly - /// check for the presence of Arg instances for a particular Option - /// and to iterate over groups of arguments. - class ArgList { - private: - ArgList(const ArgList &) LLVM_DELETED_FUNCTION; - void operator=(const ArgList &) LLVM_DELETED_FUNCTION; - - public: - typedef SmallVector<Arg*, 16> arglist_type; - typedef arglist_type::iterator iterator; - typedef arglist_type::const_iterator const_iterator; - typedef arglist_type::reverse_iterator reverse_iterator; - typedef arglist_type::const_reverse_iterator const_reverse_iterator; - - private: - /// The internal list of arguments. - arglist_type Args; - - protected: - ArgList(); - - public: - virtual ~ArgList(); - - /// @name Arg Access - /// @{ - - /// append - Append \p A to the arg list. - void append(Arg *A); - - arglist_type &getArgs() { return Args; } - const arglist_type &getArgs() const { return Args; } - - unsigned size() const { return Args.size(); } - - /// @} - /// @name Arg Iteration - /// @{ - - iterator begin() { return Args.begin(); } - iterator end() { return Args.end(); } - - reverse_iterator rbegin() { return Args.rbegin(); } - reverse_iterator rend() { return Args.rend(); } - - const_iterator begin() const { return Args.begin(); } - const_iterator end() const { return Args.end(); } - - const_reverse_iterator rbegin() const { return Args.rbegin(); } - const_reverse_iterator rend() const { return Args.rend(); } - - arg_iterator filtered_begin(OptSpecifier Id0 = 0U, OptSpecifier Id1 = 0U, - OptSpecifier Id2 = 0U) const { - return arg_iterator(Args.begin(), *this, Id0, Id1, Id2); - } - arg_iterator filtered_end() const { - return arg_iterator(Args.end(), *this); - } - - /// @} - /// @name Arg Removal - /// @{ - - /// eraseArg - Remove any option matching \p Id. - void eraseArg(OptSpecifier Id); - - /// @} - /// @name Arg Access - /// @{ - - /// hasArg - Does the arg list contain any option matching \p Id. - /// - /// \p Claim Whether the argument should be claimed, if it exists. - bool hasArgNoClaim(OptSpecifier Id) const { - return getLastArgNoClaim(Id) != 0; - } - bool hasArg(OptSpecifier Id) const { - return getLastArg(Id) != 0; - } - bool hasArg(OptSpecifier Id0, OptSpecifier Id1) const { - return getLastArg(Id0, Id1) != 0; - } - bool hasArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2) const { - return getLastArg(Id0, Id1, Id2) != 0; - } - - /// getLastArg - Return the last argument matching \p Id, or null. - /// - /// \p Claim Whether the argument should be claimed, if it exists. - Arg *getLastArgNoClaim(OptSpecifier Id) const; - Arg *getLastArg(OptSpecifier Id) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2, - OptSpecifier Id3) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2, - OptSpecifier Id3, OptSpecifier Id4) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2, - OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2, - OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5, - OptSpecifier Id6) const; - Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2, - OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5, - OptSpecifier Id6, OptSpecifier Id7) const; - - /// getArgString - Return the input argument string at \p Index. - virtual const char *getArgString(unsigned Index) const = 0; - - /// getNumInputArgStrings - Return the number of original argument strings, - /// which are guaranteed to be the first strings in the argument string - /// list. - virtual unsigned getNumInputArgStrings() const = 0; - - /// @} - /// @name Argument Lookup Utilities - /// @{ - - /// getLastArgValue - Return the value of the last argument, or a default. - StringRef getLastArgValue(OptSpecifier Id, - StringRef Default = "") const; - - /// getLastArgValue - Return the value of the last argument as an integer, - /// or a default. If Diags is non-null, emits an error if the argument - /// is given, but non-integral. - int getLastArgIntValue(OptSpecifier Id, int Default, - DiagnosticsEngine *Diags = 0) const; - - /// getLastArgValue - Return the value of the last argument as an integer, - /// or a default. Emits an error if the argument is given, but non-integral. - int getLastArgIntValue(OptSpecifier Id, int Default, - DiagnosticsEngine &Diags) const { - return getLastArgIntValue(Id, Default, &Diags); - } - - /// getAllArgValues - Get the values of all instances of the given argument - /// as strings. - std::vector<std::string> getAllArgValues(OptSpecifier Id) const; - - /// @} - /// @name Translation Utilities - /// @{ - - /// hasFlag - Given an option \p Pos and its negative form \p Neg, return - /// true if the option is present, false if the negation is present, and - /// \p Default if neither option is given. If both the option and its - /// negation are present, the last one wins. - bool hasFlag(OptSpecifier Pos, OptSpecifier Neg, bool Default = true) const; - - /// hasFlag - Given an option \p Pos, an alias \p PosAlias and its negative - /// form \p Neg, return true if the option or its alias is present, false if - /// the negation is present, and \p Default if none of the options are - /// given. If multiple options are present, the last one wins. - bool hasFlag(OptSpecifier Pos, OptSpecifier PosAlias, OptSpecifier Neg, - bool Default = true) const; - - /// AddLastArg - Render only the last argument match \p Id0, if present. - void AddLastArg(ArgStringList &Output, OptSpecifier Id0) const; - void AddLastArg(ArgStringList &Output, OptSpecifier Id0, - OptSpecifier Id1) const; - - /// AddAllArgs - Render all arguments matching the given ids. - void AddAllArgs(ArgStringList &Output, OptSpecifier Id0, - OptSpecifier Id1 = 0U, OptSpecifier Id2 = 0U) const; - - /// AddAllArgValues - Render the argument values of all arguments - /// matching the given ids. - void AddAllArgValues(ArgStringList &Output, OptSpecifier Id0, - OptSpecifier Id1 = 0U, OptSpecifier Id2 = 0U) const; - - /// AddAllArgsTranslated - Render all the arguments matching the - /// given ids, but forced to separate args and using the provided - /// name instead of the first option value. - /// - /// \param Joined - If true, render the argument as joined with - /// the option specifier. - void AddAllArgsTranslated(ArgStringList &Output, OptSpecifier Id0, - const char *Translation, - bool Joined = false) const; - - /// ClaimAllArgs - Claim all arguments which match the given - /// option id. - void ClaimAllArgs(OptSpecifier Id0) const; - - /// ClaimAllArgs - Claim all arguments. - /// - void ClaimAllArgs() const; - - /// @} - /// @name Arg Synthesis - /// @{ - - /// MakeArgString - Construct a constant string pointer whose - /// lifetime will match that of the ArgList. - virtual const char *MakeArgString(StringRef Str) const = 0; - const char *MakeArgString(const char *Str) const { - return MakeArgString(StringRef(Str)); - } - const char *MakeArgString(std::string Str) const { - return MakeArgString(StringRef(Str)); - } - const char *MakeArgString(const Twine &Str) const; - - /// \brief Create an arg string for (\p LHS + \p RHS), reusing the - /// string at \p Index if possible. - const char *GetOrMakeJoinedArgString(unsigned Index, StringRef LHS, - StringRef RHS) const; - - /// @} - - void dump(); - }; - - class InputArgList : public ArgList { - private: - /// List of argument strings used by the contained Args. - /// - /// This is mutable since we treat the ArgList as being the list - /// of Args, and allow routines to add new strings (to have a - /// convenient place to store the memory) via MakeIndex. - mutable ArgStringList ArgStrings; - - /// Strings for synthesized arguments. - /// - /// This is mutable since we treat the ArgList as being the list - /// of Args, and allow routines to add new strings (to have a - /// convenient place to store the memory) via MakeIndex. - mutable std::list<std::string> SynthesizedStrings; - - /// The number of original input argument strings. - unsigned NumInputArgStrings; - - public: - InputArgList(const char* const *ArgBegin, const char* const *ArgEnd); - ~InputArgList(); - - virtual const char *getArgString(unsigned Index) const { - return ArgStrings[Index]; - } - - virtual unsigned getNumInputArgStrings() const { - return NumInputArgStrings; - } - - /// @name Arg Synthesis - /// @{ - - public: - /// MakeIndex - Get an index for the given string(s). - unsigned MakeIndex(StringRef String0) const; - unsigned MakeIndex(StringRef String0, StringRef String1) const; - - virtual const char *MakeArgString(StringRef Str) const; - - /// @} - }; - - /// DerivedArgList - An ordered collection of driver arguments, - /// whose storage may be in another argument list. - class DerivedArgList : public ArgList { - const InputArgList &BaseArgs; - - /// The list of arguments we synthesized. - mutable arglist_type SynthesizedArgs; - - public: - /// Construct a new derived arg list from \p BaseArgs. - DerivedArgList(const InputArgList &BaseArgs); - ~DerivedArgList(); - - virtual const char *getArgString(unsigned Index) const { - return BaseArgs.getArgString(Index); - } - - virtual unsigned getNumInputArgStrings() const { - return BaseArgs.getNumInputArgStrings(); - } - - const InputArgList &getBaseArgs() const { - return BaseArgs; - } - - /// @name Arg Synthesis - /// @{ - - /// AddSynthesizedArg - Add a argument to the list of synthesized arguments - /// (to be freed). - void AddSynthesizedArg(Arg *A) { - SynthesizedArgs.push_back(A); - } - - virtual const char *MakeArgString(StringRef Str) const; - - /// AddFlagArg - Construct a new FlagArg for the given option \p Id and - /// append it to the argument list. - void AddFlagArg(const Arg *BaseArg, const Option Opt) { - append(MakeFlagArg(BaseArg, Opt)); - } - - /// AddPositionalArg - Construct a new Positional arg for the given option - /// \p Id, with the provided \p Value and append it to the argument - /// list. - void AddPositionalArg(const Arg *BaseArg, const Option Opt, - StringRef Value) { - append(MakePositionalArg(BaseArg, Opt, Value)); - } - - - /// AddSeparateArg - Construct a new Positional arg for the given option - /// \p Id, with the provided \p Value and append it to the argument - /// list. - void AddSeparateArg(const Arg *BaseArg, const Option Opt, - StringRef Value) { - append(MakeSeparateArg(BaseArg, Opt, Value)); - } - - - /// AddJoinedArg - Construct a new Positional arg for the given option - /// \p Id, with the provided \p Value and append it to the argument list. - void AddJoinedArg(const Arg *BaseArg, const Option Opt, - StringRef Value) { - append(MakeJoinedArg(BaseArg, Opt, Value)); - } - - - /// MakeFlagArg - Construct a new FlagArg for the given option \p Id. - Arg *MakeFlagArg(const Arg *BaseArg, const Option Opt) const; - - /// MakePositionalArg - Construct a new Positional arg for the - /// given option \p Id, with the provided \p Value. - Arg *MakePositionalArg(const Arg *BaseArg, const Option Opt, - StringRef Value) const; - - /// MakeSeparateArg - Construct a new Positional arg for the - /// given option \p Id, with the provided \p Value. - Arg *MakeSeparateArg(const Arg *BaseArg, const Option Opt, - StringRef Value) const; - - /// MakeJoinedArg - Construct a new Positional arg for the - /// given option \p Id, with the provided \p Value. - Arg *MakeJoinedArg(const Arg *BaseArg, const Option Opt, - StringRef Value) const; - - /// @} - }; - -} // end namespace driver -} // end namespace clang - -#endif diff --git a/include/clang/Driver/CC1AsOptions.h b/include/clang/Driver/CC1AsOptions.h index 420a101..345f50a 100644 --- a/include/clang/Driver/CC1AsOptions.h +++ b/include/clang/Driver/CC1AsOptions.h @@ -10,24 +10,27 @@ #ifndef CLANG_DRIVER_CC1ASOPTIONS_H #define CLANG_DRIVER_CC1ASOPTIONS_H +namespace llvm { +namespace opt { + class OptTable; +} +} + namespace clang { namespace driver { - class OptTable; namespace cc1asoptions { enum ID { OPT_INVALID = 0, // This is not an option ID. -#define PREFIX(NAME, VALUE) -#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, FLAGS, PARAM, \ +#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ HELPTEXT, METAVAR) OPT_##ID, #include "clang/Driver/CC1AsOptions.inc" LastOption #undef OPTION -#undef PREFIX }; } - OptTable *createCC1AsOptTable(); +llvm::opt::OptTable *createCC1AsOptTable(); } } diff --git a/include/clang/Driver/CC1AsOptions.td b/include/clang/Driver/CC1AsOptions.td index 2749bcd..b536724 100644 --- a/include/clang/Driver/CC1AsOptions.td +++ b/include/clang/Driver/CC1AsOptions.td @@ -12,7 +12,7 @@ //===----------------------------------------------------------------------===// // Include the common option parsing interfaces. -include "OptParser.td" +include "llvm/Option/OptParser.td" //===----------------------------------------------------------------------===// // Target Options @@ -33,7 +33,7 @@ def I : JoinedOrSeparate<["-"], "I">, MetaVarName<"<directory>">, HelpText<"Add directory to include search path">; def n : Flag<["-"], "n">, HelpText<"Don't automatically start assembly file with a text section">; -def L : Flag<["-"], "L">, +def msave_temp_labels : Flag<["-"], "msave-temp-labels">, HelpText<"Save temporary labels in the symbol table. " "Note this may change .s semantics, it should almost never be used " "on compiler generated code!">; @@ -77,15 +77,12 @@ def show_inst : Flag<["-"], "show-inst">, // Assemble Options //===----------------------------------------------------------------------===// -def relax_all : Flag<["-"], "relax-all">, +def mrelax_all : Flag<["-"], "mrelax-all">, HelpText<"Relax all fixups (for performance testing)">; -def no_exec_stack : Flag<["--"], "noexecstack">, +def mno_exec_stack : Flag<["-"], "mnoexecstack">, HelpText<"Mark the file as not needing an executable stack">; -def fatal_warnings : Flag<["--"], "fatal-warnings">, - HelpText<"Consider warnings as errors">; - def g : Flag<["-"], "g">, HelpText<"Generate source level debug information">; def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">, diff --git a/include/clang/Driver/CC1Options.td b/include/clang/Driver/CC1Options.td index 96a50fc..85cfdcf 100644 --- a/include/clang/Driver/CC1Options.td +++ b/include/clang/Driver/CC1Options.td @@ -23,6 +23,8 @@ def target_abi : Separate<["-"], "target-abi">, HelpText<"Target a particular ABI type">; def target_cpu : Separate<["-"], "target-cpu">, HelpText<"Target a specific cpu type">; +def mfpmath : Separate<["-"], "mfpmath">, + HelpText<"Which unit to use for fp math">; def target_feature : Separate<["-"], "target-feature">, HelpText<"Target specific attributes">; def target_linker_version : Separate<["-"], "target-linker-version">, @@ -136,6 +138,8 @@ def dwarf_column_info : Flag<["-"], "dwarf-column-info">, HelpText<"Turn on column location information.">; def split_dwarf : Flag<["-"], "split-dwarf">, HelpText<"Split out the dwarf .dwo sections">; +def gnu_pubnames : Flag<["-"], "gnu-pubnames">, + HelpText<"Emit newer GNU style pubnames">; def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">, HelpText<"Emit an error if a C++ static local initializer would need a guard variable">; def no_implicit_float : Flag<["-"], "no-implicit-float">, @@ -161,8 +165,8 @@ def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfie HelpText<"Use register sized accesses to bit-fields, when possible.">; def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">, HelpText<"Turn off Type Based Alias Analysis">; -def struct_path_tbaa : Flag<["-"], "struct-path-tbaa">, - HelpText<"Turn on struct-path aware Type Based Alias Analysis">; +def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">, + HelpText<"Turn off struct-path aware Type Based Alias Analysis">; def masm_verbose : Flag<["-"], "masm-verbose">, HelpText<"Generate verbose assembly output">; def mcode_model : Separate<["-"], "mcode-model">, @@ -204,6 +208,14 @@ def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">, HelpText<"Emit complete constructors and destructors as aliases when possible">; def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">, HelpText<"Link the given bitcode file before performing optimizations.">; +def vectorize_loops : Flag<["-"], "vectorize-loops">, + HelpText<"Run the Loop vectorization passes">; +def vectorize_slp : Flag<["-"], "vectorize-slp">, + HelpText<"Run the SLP vectorization passes">; +def vectorize_slp_aggressive : Flag<["-"], "vectorize-slp-aggressive">, + HelpText<"Run the BB vectorization passes">; +def dependent_lib : Joined<["--"], "dependent-lib=">, + HelpText<"Add dependent library">; //===----------------------------------------------------------------------===// // Dependency Output Options @@ -213,6 +225,8 @@ def sys_header_deps : Flag<["-"], "sys-header-deps">, HelpText<"Include system headers in dependency output">; def header_include_file : Separate<["-"], "header-include-file">, HelpText<"Filename (or -) to write header include output to">; +def show_includes : Flag<["--"], "show-includes">, + HelpText<"Print cl.exe style /showIncludes to stderr">; //===----------------------------------------------------------------------===// // Diagnostic Options @@ -290,6 +304,8 @@ def ast_dump_filter : Separate<["-"], "ast-dump-filter">, HelpText<"Use with -ast-dump or -ast-print to dump/print only AST declaration" " nodes having a certain substring in a qualified name. Use" " -ast-list to list all filterable declaration node names.">; +def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">, + HelpText<"Include name lookup table dumps in AST dumps">; def fno_modules_global_index : Flag<["-"], "fno-modules-global-index">, HelpText<"Do not automatically generate or update the global module index">; @@ -320,8 +336,6 @@ def ast_list : Flag<["-"], "ast-list">, HelpText<"Build ASTs and print the list of declaration node qualified names">; def ast_dump : Flag<["-"], "ast-dump">, HelpText<"Build ASTs and then debug dump them">; -def ast_dump_xml : Flag<["-"], "ast-dump-xml">, - HelpText<"Build ASTs and then debug dump them in a verbose XML format">; def ast_view : Flag<["-"], "ast-view">, HelpText<"Build ASTs and view them with GraphViz">; def print_decl_contexts : Flag<["-"], "print-decl-contexts">, @@ -357,8 +371,6 @@ def arcmt_modify : Flag<["-"], "arcmt-modify">, def arcmt_migrate : Flag<["-"], "arcmt-migrate">, HelpText<"Apply modifications and produces temporary files that conform to ARC">; -def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, - HelpText<"Whether to build a relocatable precompiled header">; def print_stats : Flag<["-"], "print-stats">, HelpText<"Print performance metrics and statistics">; def fdump_record_layouts : Flag<["-"], "fdump-record-layouts">, @@ -391,8 +403,6 @@ def main_file_name : Separate<["-"], "main-file-name">, HelpText<"Main file name to use for debug info">; def split_dwarf_file : Separate<["-"], "split-dwarf-file">, HelpText<"File name to use for split dwarf debug info output">; -def fno_signed_char : Flag<["-"], "fno-signed-char">, - HelpText<"Char is unsigned">; def fno_wchar : Flag<["-"], "fno-wchar">, HelpText<"Disable C++ builtin type wchar_t">; def fconstant_string_class : Separate<["-"], "fconstant-string-class">, @@ -404,8 +414,8 @@ def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">, HelpText<"The target Objective-C runtime supports ARC weak operations">; def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">, HelpText<"Objective-C dispatch method to use">; -def fobjc_default_synthesize_properties : Flag<["-"], "fobjc-default-synthesize-properties">, - HelpText<"enable the default synthesis of Objective-C properties">; +def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">, + HelpText<"disable the default synthesis of Objective-C properties">; def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">, HelpText<"enable extended encoding of block type signature">; def pic_level : Separate<["-"], "pic-level">, @@ -432,8 +442,12 @@ def ftype_visibility : Separate<["-"], "ftype-visibility">, HelpText<"Default type visibility">; def ftemplate_depth : Separate<["-"], "ftemplate-depth">, HelpText<"Maximum depth of recursive template instantiation">; +def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">, + HelpText<"Maximum number of 'operator->'s to call for a member access">; def fconstexpr_depth : Separate<["-"], "fconstexpr-depth">, HelpText<"Maximum depth of recursive constexpr function calls">; +def fconstexpr_steps : Separate<["-"], "fconstexpr-steps">, + HelpText<"Maximum number of steps in constexpr function evaluation">; def fbracket_depth : Separate<["-"], "fbracket-depth">, HelpText<"Maximum nesting level for parentheses, brackets, and braces">; def fconst_strings : Flag<["-"], "fconst-strings">, @@ -444,6 +458,8 @@ def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">, HelpText<"Ignore bit-field types when aligning structures">; def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">, HelpText<"Use a fake address space map; OpenCL testing purposes only">; +def faddress_space_map_mangling_EQ : Joined<["-"], "faddress-space-map-mangling=">, MetaVarName<"<yes|no|target>">, + HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">; def funknown_anytype : Flag<["-"], "funknown-anytype">, HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">; def fdebugger_support : Flag<["-"], "fdebugger-support">, @@ -456,6 +472,10 @@ def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">, HelpText<"Defines the __DEPRECATED macro">; def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">, HelpText<"Undefines the __DEPRECATED macro">; +def fsized_deallocation : Flag<["-"], "fsized-deallocation">, + HelpText<"Enable C++1y sized global deallocation functions">; +def fobjc_subscripting_legacy_runtime : Flag<["-"], "fobjc-subscripting-legacy-runtime">, + HelpText<"Allow Objective-C array and dictionary subscripting in legacy runtime">; //===----------------------------------------------------------------------===// // Header Search Options @@ -463,9 +483,6 @@ def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">, def nostdsysteminc : Flag<["-"], "nostdsysteminc">, HelpText<"Disable standard system #include directories">; -def fmodule_name : Joined<["-"], "fmodule-name=">, - MetaVarName<"<name>">, - HelpText<"Specify the name of the module to build">; def fdisable_module_hash : Flag<["-"], "fdisable-module-hash">, HelpText<"Disable the module hash">; def c_isystem : JoinedOrSeparate<["-"], "c-isystem">, MetaVarName<"<directory>">, diff --git a/include/clang/Driver/CLCompatOptions.td b/include/clang/Driver/CLCompatOptions.td new file mode 100644 index 0000000..d17a63c --- /dev/null +++ b/include/clang/Driver/CLCompatOptions.td @@ -0,0 +1,255 @@ +//===--- CLCompatOptions.td - Options for clang-cl ------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the options accepted by clang-cl. +// +//===----------------------------------------------------------------------===// + +def cl_Group : OptionGroup<"<clang-cl options>">, + HelpText<"CL.EXE COMPATIBILITY OPTIONS">; + +def cl_compile_Group : OptionGroup<"<clang-cl compile-only options>">, + Group<cl_Group>; + +def cl_ignored_Group : OptionGroup<"<clang-cl ignored options>">, + Group<cl_Group>; + +class CLFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, + Group<cl_Group>, Flags<[CLOption, DriverOption]>; + +class CLCompileFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, + Group<cl_compile_Group>, Flags<[CLOption, DriverOption]>; + +class CLIgnoredFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, + Group<cl_ignored_Group>, Flags<[CLOption, DriverOption, HelpHidden]>; + +class CLJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, + Group<cl_Group>, Flags<[CLOption, DriverOption]>; + +class CLCompileJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, + Group<cl_compile_Group>, Flags<[CLOption, DriverOption]>; + +class CLIgnoredJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, + Group<cl_ignored_Group>, Flags<[CLOption, DriverOption, HelpHidden]>; + +class CLJoinedOrSeparate<string name> : Option<["/", "-"], name, + KIND_JOINED_OR_SEPARATE>, Group<cl_Group>, Flags<[CLOption, DriverOption]>; + +class CLCompileJoinedOrSeparate<string name> : Option<["/", "-"], name, + KIND_JOINED_OR_SEPARATE>, Group<cl_compile_Group>, + Flags<[CLOption, DriverOption]>; + +class CLRemainingArgs<string name> : Option<["/", "-"], name, + KIND_REMAINING_ARGS>, Group<cl_Group>, Flags<[CLOption, DriverOption]>; + +// Aliases: +// (We don't put any of these in cl_compile_Group as the options they alias are +// already in the right group.) + +def _SLASH_C : CLFlag<"C">, HelpText<"Don't discard comments when preprocessing">, + Alias<C>; +def _SLASH_c : CLFlag<"c">, HelpText<"Compile only">, Alias<c>; +def _SLASH_D : CLJoinedOrSeparate<"D">, HelpText<"Define macro">, + MetaVarName<"<macro[=value]>">, Alias<D>; +def _SLASH_GR : CLFlag<"GR">, HelpText<"Enable RTTI">, Alias<frtti>; +def _SLASH_GR_ : CLFlag<"GR-">, HelpText<"Disable RTTI">, Alias<fno_rtti>; +def _SLASH_GF_ : CLFlag<"GF-">, HelpText<"Disable string pooling">, + Alias<fwritable_strings>; +def _SLASH_help : CLFlag<"help">, Alias<help>, + HelpText<"Display available options">; +def _SLASH_HELP : CLFlag<"HELP">, Alias<help>; +def _SLASH_I : CLJoinedOrSeparate<"I">, + HelpText<"Add directory to include search path">, MetaVarName<"<dir>">, + Alias<I>; +def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">, + Alias<funsigned_char>; +def _SLASH_O : CLJoined<"O">, HelpText<"Optimization level">, + MetaVarName<"<n>">, Alias<O>; +def _SLASH_Ob0 : CLFlag<"Ob0">, HelpText<"Disable inlining">, + Alias<fno_inline>; +def _SLASH_Od : CLFlag<"Od">, HelpText<"Disable optimization">, Alias<O0>; +def _SLASH_Oi : CLFlag<"Oi">, HelpText<"Enable use of builtin functions">, + Alias<fbuiltin>; +def _SLASH_Oi_ : CLFlag<"Oi-">, HelpText<"Disable use of builtin functions">, + Alias<fno_builtin>; +def _SLASH_Os : CLFlag<"Os">, HelpText<"Optimize for size">, Alias<O>, + AliasArgs<["s"]>; +def _SLASH_Ot : CLFlag<"Ot">, HelpText<"Optimize for speed">, Alias<O>, + AliasArgs<["2"]>; +def _SLASH_Ox : CLFlag<"Ox">, HelpText<"Maximum optimization">, Alias<O>, + AliasArgs<["3"]>; +def _SLASH_Oy : CLFlag<"Oy">, HelpText<"Enable frame pointer omission">, + Alias<fomit_frame_pointer>; +def _SLASH_Oy_ : CLFlag<"Oy-">, HelpText<"Disable frame pointer omission">, + Alias<fno_omit_frame_pointer>; +def _SLASH_P : CLFlag<"P">, HelpText<"Only run the preprocessor">, Alias<E>; +def _SLASH_QUESTION : CLFlag<"?">, Alias<help>, + HelpText<"Display available options">; +def _SLASH_showIncludes : CLFlag<"showIncludes">, + HelpText<"Print info about included files to stderr">, + Alias<show_includes>; +def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">, + MetaVarName<"<macro>">, Alias<U>; +def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>; +def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>; +def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>; +def _SLASH_W3 : CLFlag<"W3">, HelpText<"Enable -Wall">, Alias<Wall>; +def _SLASH_W4 : CLFlag<"W4">, HelpText<"Enable -Wall">, Alias<Wall>; +def _SLASH_Wall : CLFlag<"Wall">, HelpText<"Enable -Wall">, Alias<Wall>; +def _SLASH_WX : CLFlag<"WX">, HelpText<"Treat warnings as errors">, + Alias<W_Joined>, AliasArgs<["error"]>; +def _SLASH_WX_ : CLFlag<"WX-">, HelpText<"Do not treat warnings as errors">, + Alias<W_Joined>, AliasArgs<["no-error"]>; +def _SLASH_w_flag : CLFlag<"w">, HelpText<"Disable all warnings">, Alias<w>; +def _SLASH_Zs : CLFlag<"Zs">, HelpText<"Syntax-check only">, + Alias<fsyntax_only>; + + +// Non-aliases: + +def _SLASH_M_Group : OptionGroup<"</M group>">, Group<cl_compile_Group>; + +def _SLASH_FA : CLFlag<"FA">, + HelpText<"Output assembly code file during compilation">; +def _SLASH_Fa : CLJoined<"Fa">, + HelpText<"Output assembly code to this file during compilation">, + MetaVarName<"<file or directory>">; +def _SLASH_fallback : CLCompileFlag<"fallback">, + HelpText<"Fall back to cl.exe if clang-cl fails to compile">; +def _SLASH_FI : CLJoinedOrSeparate<"FI">, + HelpText<"Include file before parsing">, Alias<include_>; +def _SLASH_Fe : CLJoined<"Fe">, + HelpText<"Set output executable file or directory (ends in / or \\)">, + MetaVarName<"<file or directory>">; +def _SLASH_Fo : CLCompileJoined<"Fo">, + HelpText<"Set output object file, or directory (ends in / or \\)">, + MetaVarName<"<file or directory>">; +def _SLASH_LD : CLFlag<"LD">, HelpText<"Create DLL">; +def _SLASH_LDd : CLFlag<"LDd">, HelpText<"Create debug DLL">; +def _SLASH_link : CLRemainingArgs<"link">, + HelpText<"Forward options to the linker">, MetaVarName<"<options>">; +def _SLASH_MD : Option<["/", "-"], "MD", KIND_FLAG>, Group<_SLASH_M_Group>, + Flags<[CLOption, DriverOption]>, HelpText<"Use DLL run-time">; +def _SLASH_MDd : Option<["/", "-"], "MDd", KIND_FLAG>, Group<_SLASH_M_Group>, + Flags<[CLOption, DriverOption]>, HelpText<"Use DLL debug run-time">; +def _SLASH_MT : Option<["/", "-"], "MT", KIND_FLAG>, Group<_SLASH_M_Group>, + Flags<[CLOption, DriverOption]>, HelpText<"Use static run-time">; +def _SLASH_MTd : Option<["/", "-"], "MTd", KIND_FLAG>, Group<_SLASH_M_Group>, + Flags<[CLOption, DriverOption]>, HelpText<"Use static debug run-time">; +def _SLASH_Tc : CLCompileJoinedOrSeparate<"Tc">, + HelpText<"Specify a C source file">, MetaVarName<"<filename>">; +def _SLASH_TC : CLCompileFlag<"TC">, HelpText<"Treat all source files as C">; +def _SLASH_Tp : CLCompileJoinedOrSeparate<"Tp">, + HelpText<"Specify a C++ source file">, MetaVarName<"<filename>">; +def _SLASH_TP : CLCompileFlag<"TP">, HelpText<"Treat all source files as C++">; + + +// Ignored: + +def _SLASH_analyze_ : CLIgnoredFlag<"analyze-">; +def _SLASH_errorReport : CLIgnoredJoined<"errorReport">; +def _SLASH_FS : CLIgnoredFlag<"FS">, HelpText<"Force synchronous PDB writes">; +def _SLASH_GF : CLIgnoredFlag<"GF">; +def _SLASH_GS_ : CLIgnoredFlag<"GS-">; +def _SLASH_kernel_ : CLIgnoredFlag<"kernel-">; +def _SLASH_nologo : CLIgnoredFlag<"nologo">; +def _SLASH_Ob1 : CLIgnoredFlag<"Ob1">; +def _SLASH_Ob2 : CLIgnoredFlag<"Ob2">; +def _SLASH_RTC : CLIgnoredJoined<"RTC">; +def _SLASH_sdl : CLIgnoredFlag<"sdl">; +def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">; +def _SLASH_vmg : CLIgnoredFlag<"vmg">; +def _SLASH_w : CLIgnoredJoined<"w">; +def _SLASH_Zc_forScope : CLIgnoredFlag<"Zc:forScope">; +def _SLASH_Zc_wchar_t : CLIgnoredFlag<"Zc:wchar_t">; +def _SLASH_Zm : CLIgnoredJoined<"Zm">; + + +// Unsupported: + +def _SLASH_AI : CLJoined<"AI">; +def _SLASH_arch : CLJoined<"arch:">; +def _SLASH_bigobj : CLFlag<"bigobj">; +def _SLASH_clr : CLJoined<"clr">; +def _SLASH_doc : CLJoined<"doc">; +def _SLASH_E : CLFlag<"E">; +def _SLASH_EH : CLJoined<"EH">; +def _SLASH_EP : CLFlag<"EP">; +def _SLASH_FA_joined : CLJoined<"FA">; +def _SLASH_favor : CLJoined<"favor">; +def _SLASH_FC : CLFlag<"FC">; +def _SLASH_F : CLFlag<"F">; +def _SLASH_Fd : CLJoined<"Fd">; +def _SLASH_Fi : CLJoined<"Fi">; +def _SLASH_Fm : CLJoined<"Fm">; +def _SLASH_fp : CLJoined<"fp">; +def _SLASH_Fp : CLJoined<"Fp">; +def _SLASH_Fr : CLJoined<"Fr">; +def _SLASH_FR : CLJoined<"FR">; +def _SLASH_FU : CLJoinedOrSeparate<"FU">; +def _SLASH_Fx : CLFlag<"Fx">; +def _SLASH_G1 : CLFlag<"G1">; +def _SLASH_G2 : CLFlag<"G2">; +def _SLASH_GA : CLFlag<"GA">; +def _SLASH_Gd : CLFlag<"Gd">; +def _SLASH_Ge : CLFlag<"Ge">; +def _SLASH_Gh : CLFlag<"Gh">; +def _SLASH_GH : CLFlag<"GH">; +def _SLASH_GL : CLFlag<"GL">; +def _SLASH_GL_ : CLFlag<"GL-">; +def _SLASH_Gm : CLFlag<"Gm">; +def _SLASH_Gm_ : CLFlag<"Gm-">; +def _SLASH_Gr : CLFlag<"Gr">; +def _SLASH_GS : CLFlag<"GS">; +def _SLASH_Gs : CLJoined<"Gs">; +def _SLASH_GT : CLFlag<"GT">; +def _SLASH_GX : CLFlag<"GX">; +def _SLASH_Gy : CLFlag<"Gy">; +def _SLASH_Gy_ : CLFlag<"Gy-">; +def _SLASH_Gz : CLFlag<"Gz">; +def _SLASH_GZ : CLFlag<"GZ">; +def _SLASH_H : CLFlag<"H">; +def _SLASH_homeparams : CLFlag<"homeparams">; +def _SLASH_hotpatch : CLFlag<"hotpatch">; +def _SLASH_kernel : CLFlag<"kernel">; +def _SLASH_LN : CLFlag<"LN">; +def _SLASH_MP : CLJoined<"MP">; +def _SLASH_o : CLJoinedOrSeparate<"o">; +def _SLASH_openmp : CLFlag<"openmp">; +def _SLASH_Qfast_transcendentals : CLFlag<"Qfast_transcendentals">; +def _SLASH_QIfist : CLFlag<"QIfist">; +def _SLASH_Qimprecise_fwaits : CLFlag<"Qimprecise_fwaits">; +def _SLASH_Qpar : CLFlag<"Qpar">; +def _SLASH_Qvec_report : CLJoined<"Qvec-report">; +def _SLASH_u : CLFlag<"u">; +def _SLASH_V : CLFlag<"V">; +def _SLASH_vd : CLJoined<"vd">; +def _SLASH_vmb : CLFlag<"vmb">; +def _SLASH_vmm : CLFlag<"vmm">; +def _SLASH_vms : CLFlag<"vms">; +def _SLASH_vmv : CLFlag<"vmv">; +def _SLASH_volatile : CLFlag<"volatile">; +def _SLASH_WL : CLFlag<"WL">; +def _SLASH_Wp64 : CLFlag<"Wp64">; +def _SLASH_X : CLFlag<"X">; +def _SLASH_Yc : CLJoined<"Yc">; +def _SLASH_Y_ : CLFlag<"Y-">; +def _SLASH_Yd : CLFlag<"Yd">; +def _SLASH_Yl : CLJoined<"Yl">; +def _SLASH_Yu : CLJoined<"Yu">; +def _SLASH_Z7 : CLFlag<"Z7">; +def _SLASH_Za : CLFlag<"Za">; +def _SLASH_Zc : CLJoined<"Zc:">; +def _SLASH_Ze : CLFlag<"Ze">; +def _SLASH_Zg : CLFlag<"Zg">; +def _SLASH_Zi : CLFlag<"Zi">; +def _SLASH_ZI : CLFlag<"ZI">; +def _SLASH_Zl : CLFlag<"Zl">; +def _SLASH_Zp : CLFlag<"Zp">; +def _SLASH_ZW : CLJoined<"ZW">; diff --git a/include/clang/Driver/CMakeLists.txt b/include/clang/Driver/CMakeLists.txt index 1277d51..5961cac 100644 --- a/include/clang/Driver/CMakeLists.txt +++ b/include/clang/Driver/CMakeLists.txt @@ -1,7 +1,7 @@ -clang_tablegen(Options.inc -gen-opt-parser-defs - SOURCE Options.td - TARGET ClangDriverOptions) +set(LLVM_TARGET_DEFINITIONS Options.td) +tablegen(LLVM Options.inc -gen-opt-parser-defs) +add_public_tablegen_target(ClangDriverOptions) -clang_tablegen(CC1AsOptions.inc -gen-opt-parser-defs - SOURCE CC1AsOptions.td - TARGET ClangCC1AsOptions) +set(LLVM_TARGET_DEFINITIONS CC1AsOptions.td) +tablegen(LLVM CC1AsOptions.inc -gen-opt-parser-defs) +add_public_tablegen_target(ClangCC1AsOptions) diff --git a/include/clang/Driver/Compilation.h b/include/clang/Driver/Compilation.h index 15c5e40..3493e4f 100644 --- a/include/clang/Driver/Compilation.h +++ b/include/clang/Driver/Compilation.h @@ -15,11 +15,16 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/Support/Path.h" +namespace llvm { +namespace opt { + class DerivedArgList; + class InputArgList; +} +} + namespace clang { namespace driver { - class DerivedArgList; class Driver; - class InputArgList; class JobAction; class JobList; class ToolChain; @@ -34,11 +39,11 @@ class Compilation { const ToolChain &DefaultToolChain; /// The original (untranslated) input argument list. - InputArgList *Args; + llvm::opt::InputArgList *Args; /// The driver translated arguments. Note that toolchains may perform their /// own argument translation. - DerivedArgList *TranslatedArgs; + llvm::opt::DerivedArgList *TranslatedArgs; /// The list of actions. ActionList Actions; @@ -48,11 +53,11 @@ class Compilation { /// Cache of translated arguments for a particular tool chain and bound /// architecture. - llvm::DenseMap<std::pair<const ToolChain*, const char*>, - DerivedArgList*> TCArgs; + llvm::DenseMap<std::pair<const ToolChain *, const char *>, + llvm::opt::DerivedArgList *> TCArgs; /// Temporary files which should be removed on exit. - ArgStringList TempFiles; + llvm::opt::ArgStringList TempFiles; /// Result files which should be removed on failure. ArgStringMap ResultFiles; @@ -62,22 +67,23 @@ class Compilation { ArgStringMap FailureResultFiles; /// Redirection for stdout, stderr, etc. - const llvm::sys::Path **Redirects; + const StringRef **Redirects; public: Compilation(const Driver &D, const ToolChain &DefaultToolChain, - InputArgList *Args, DerivedArgList *TranslatedArgs); + llvm::opt::InputArgList *Args, + llvm::opt::DerivedArgList *TranslatedArgs); ~Compilation(); const Driver &getDriver() const { return TheDriver; } const ToolChain &getDefaultToolChain() const { return DefaultToolChain; } - const InputArgList &getInputArgs() const { return *Args; } + const llvm::opt::InputArgList &getInputArgs() const { return *Args; } - const DerivedArgList &getArgs() const { return *TranslatedArgs; } + const llvm::opt::DerivedArgList &getArgs() const { return *TranslatedArgs; } - DerivedArgList &getArgs() { return *TranslatedArgs; } + llvm::opt::DerivedArgList &getArgs() { return *TranslatedArgs; } ActionList &getActions() { return Actions; } const ActionList &getActions() const { return Actions; } @@ -87,7 +93,7 @@ public: void addCommand(Command *C) { Jobs.addJob(C); } - const ArgStringList &getTempFiles() const { return TempFiles; } + const llvm::opt::ArgStringList &getTempFiles() const { return TempFiles; } const ArgStringMap &getResultFiles() const { return ResultFiles; } @@ -102,8 +108,8 @@ public: /// tool chain \p TC (or the default tool chain, if TC is not specified). /// /// \param BoundArch - The bound architecture name, or 0. - const DerivedArgList &getArgsForToolChain(const ToolChain *TC, - const char *BoundArch); + const llvm::opt::DerivedArgList &getArgsForToolChain(const ToolChain *TC, + const char *BoundArch); /// addTempFile - Add a file to remove on exit, and returns its /// argument. @@ -136,7 +142,7 @@ public: /// /// \param IssueErrors - Report failures as errors. /// \return Whether all files were removed successfully. - bool CleanupFileList(const ArgStringList &Files, + bool CleanupFileList(const llvm::opt::ArgStringList &Files, bool IssueErrors = false) const; /// CleanupFileMap - Remove the files in the given map. @@ -149,23 +155,6 @@ public: const JobAction *JA, bool IssueErrors = false) const; - /// PrintJob - Print one job in -### format. - /// - /// \param OS - The stream to print on. - /// \param J - The job to print. - /// \param Terminator - A string to print at the end of the line. - /// \param Quote - Should separate arguments be quoted. - void PrintJob(raw_ostream &OS, const Job &J, - const char *Terminator, bool Quote) const; - - /// PrintDiagnosticJob - Print one job in -### format, but with the - /// superfluous options removed, which are not necessary for - /// reproducing the crash. - /// - /// \param OS - The stream to print on. - /// \param J - The job to print. - void PrintDiagnosticJob(raw_ostream &OS, const Job &J) const; - /// ExecuteCommand - Execute an actual command. /// /// \param FailingCommand - For non-zero results, this will be set to the diff --git a/include/clang/Driver/Driver.h b/include/clang/Driver/Driver.h index d9053d1..867444e 100644 --- a/include/clang/Driver/Driver.h +++ b/include/clang/Driver/Driver.h @@ -15,6 +15,7 @@ #include "clang/Driver/Phases.h" #include "clang/Driver/Types.h" #include "clang/Driver/Util.h" +#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Triple.h" @@ -24,27 +25,41 @@ #include <set> #include <string> +namespace llvm { +namespace opt { + class Arg; + class ArgList; + class DerivedArgList; + class InputArgList; + class OptTable; +} +} + namespace clang { namespace driver { + class Action; - class Arg; - class ArgList; class Command; class Compilation; - class DerivedArgList; - class InputArgList; class InputInfo; class JobAction; - class OptTable; + class SanitizerArgs; class ToolChain; /// Driver - Encapsulate logic for constructing compilation processes /// from a set of gcc-driver-like command line arguments. class Driver { - OptTable *Opts; + llvm::opt::OptTable *Opts; DiagnosticsEngine &Diags; + enum DriverMode { + GCCMode, + GXXMode, + CPPMode, + CLMode + } Mode; + public: // Diag - Forwarding function for diagnostics. DiagnosticBuilder Diag(unsigned DiagID) const { @@ -79,6 +94,9 @@ public: /// sysroot, if present std::string SysRoot; + /// Dynamic loader prefix, if present + std::string DyldPrefix; + /// If the standard library is used bool UseStdLib; @@ -104,16 +122,17 @@ public: const char *CCLogDiagnosticsFilename; /// A list of inputs and their types for the given arguments. - typedef SmallVector<std::pair<types::ID, const Arg*>, 16> InputList; + typedef SmallVector<std::pair<types::ID, const llvm::opt::Arg *>, 16> + InputList; /// Whether the driver should follow g++ like behavior. - unsigned CCCIsCXX : 1; + bool CCCIsCXX() const { return Mode == GXXMode; } /// Whether the driver is just the preprocessor. - unsigned CCCIsCPP : 1; + bool CCCIsCPP() const { return Mode == CPPMode; } - /// Echo commands while executing (in -v style). - unsigned CCCEcho : 1; + /// Whether the driver should follow cl.exe like behavior. + bool IsCLMode() const { return Mode == CLMode; } /// Only print tool bindings, don't build any jobs. unsigned CCCPrintBindings : 1; @@ -163,12 +182,13 @@ private: private: /// TranslateInputArgs - Create a new derived argument list from the input /// arguments, after applying the standard argument translations. - DerivedArgList *TranslateInputArgs(const InputArgList &Args) const; + llvm::opt::DerivedArgList * + TranslateInputArgs(const llvm::opt::InputArgList &Args) const; // getFinalPhase - Determine which compilation mode we are in and record // which option we used to determine the final phase. - phases::ID getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg = 0) - const; + phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL, + llvm::opt::Arg **FinalPhaseArg = 0) const; public: Driver(StringRef _ClangExecutable, @@ -183,8 +203,7 @@ public: /// Name to use when invoking gcc/g++. const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; } - - const OptTable &getOpts() const { return *Opts; } + const llvm::opt::OptTable &getOpts() const { return *Opts; } const DiagnosticsEngine &getDiags() const { return Diags; } @@ -226,9 +245,12 @@ public: /// @name Driver Steps /// @{ + /// ParseDriverMode - Look for and handle the driver mode option in Args. + void ParseDriverMode(ArrayRef<const char *> Args); + /// ParseArgStrings - Parse the given list of strings into an /// ArgList. - InputArgList *ParseArgStrings(ArrayRef<const char *> Args); + llvm::opt::InputArgList *ParseArgStrings(ArrayRef<const char *> Args); /// BuildInputs - Construct the list of inputs and their types from /// the given arguments. @@ -237,7 +259,7 @@ public: /// \param Args - The input arguments. /// \param Inputs - The list to store the resulting compilation /// inputs onto. - void BuildInputs(const ToolChain &TC, const DerivedArgList &Args, + void BuildInputs(const ToolChain &TC, const llvm::opt::DerivedArgList &Args, InputList &Inputs) const; /// BuildActions - Construct the list of actions to perform for the @@ -246,7 +268,7 @@ public: /// \param TC - The default host tool chain. /// \param Args - The input arguments. /// \param Actions - The list to store the resulting actions onto. - void BuildActions(const ToolChain &TC, const DerivedArgList &Args, + void BuildActions(const ToolChain &TC, llvm::opt::DerivedArgList &Args, const InputList &Inputs, ActionList &Actions) const; /// BuildUniversalActions - Construct the list of actions to perform @@ -255,7 +277,8 @@ public: /// \param TC - The default host tool chain. /// \param Args - The input arguments. /// \param Actions - The list to store the resulting actions onto. - void BuildUniversalActions(const ToolChain &TC, const DerivedArgList &Args, + void BuildUniversalActions(const ToolChain &TC, + llvm::opt::DerivedArgList &Args, const InputList &BAInputs, ActionList &Actions) const; @@ -292,9 +315,6 @@ public: /// \param ShowHidden - Show hidden options. void PrintHelp(bool ShowHidden) const; - /// PrintOptions - Print the list of arguments. - void PrintOptions(const ArgList &Args) const; - /// PrintVersion - Print the driver version. void PrintVersion(const Compilation &C, raw_ostream &OS) const; @@ -324,10 +344,9 @@ public: /// ConstructAction - Construct the appropriate action to do for /// \p Phase on the \p Input, taking in to account arguments /// like -fsyntax-only or --analyze. - Action *ConstructPhaseAction(const ArgList &Args, phases::ID Phase, + Action *ConstructPhaseAction(const llvm::opt::ArgList &Args, phases::ID Phase, Action *Input) const; - /// BuildJobsForAction - Construct the jobs to perform for the /// action \p A. void BuildJobsForAction(Compilation &C, @@ -367,18 +386,22 @@ public: /// handle this action. bool ShouldUseClangCompiler(const JobAction &JA) const; - bool IsUsingLTO(const ArgList &Args) const; + bool IsUsingLTO(const llvm::opt::ArgList &Args) const; private: /// \brief Retrieves a ToolChain for a particular target triple. /// /// Will cache ToolChains for the life of the driver object, and create them /// on-demand. - const ToolChain &getToolChain(const ArgList &Args, + const ToolChain &getToolChain(const llvm::opt::ArgList &Args, StringRef DarwinArchName = "") const; /// @} + /// \brief Get bitmasks for which option flags to include and exclude based on + /// the driver mode. + std::pair<unsigned, unsigned> getIncludeExcludeOptionFlagMasks() const; + public: /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and /// return the grouped values as integers. Numbers which are not diff --git a/include/clang/Driver/DriverDiagnostic.h b/include/clang/Driver/DriverDiagnostic.h index ea7b52f..f3c33ae 100644 --- a/include/clang/Driver/DriverDiagnostic.h +++ b/include/clang/Driver/DriverDiagnostic.h @@ -16,7 +16,7 @@ namespace clang { namespace diag { enum { #define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\ - SFINAE,ACCESS,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM, + SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM, #define DRIVERSTART #include "clang/Basic/DiagnosticDriverKinds.inc" #undef DIAG diff --git a/include/clang/Driver/Job.h b/include/clang/Driver/Job.h index 045b5d8..1dd49a7 100644 --- a/include/clang/Driver/Job.h +++ b/include/clang/Driver/Job.h @@ -11,18 +11,28 @@ #define CLANG_DRIVER_JOB_H_ #include "clang/Basic/LLVM.h" -#include "clang/Driver/Util.h" +#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/Option/Option.h" + +namespace llvm { + class raw_ostream; +} namespace clang { namespace driver { +class Action; class Command; class Tool; +// Re-export this as clang::driver::ArgStringList. +using llvm::opt::ArgStringList; + class Job { public: enum JobClass { CommandClass, + FallbackCommandClass, JobListClass }; @@ -36,16 +46,19 @@ public: JobClass getKind() const { return Kind; } - /// addCommand - Append a command to the current job, which must be - /// either a piped job or a job list. - void addCommand(Command *C); + /// Print - Print this Job in -### format. + /// + /// \param OS - The stream to print on. + /// \param Terminator - A string to print at the end of the line. + /// \param Quote - Should separate arguments be quoted. + /// \param CrashReport - Whether to print for inclusion in a crash report. + virtual void Print(llvm::raw_ostream &OS, const char *Terminator, + bool Quote, bool CrashReport = false) const = 0; }; - /// Command - An executable path/name and argument vector to - /// execute. +/// Command - An executable path/name and argument vector to +/// execute. class Command : public Job { - virtual void anchor(); - /// Source - The action which caused the creation of this job. const Action &Source; @@ -57,11 +70,17 @@ class Command : public Job { /// The list of program arguments (not including the implicit first /// argument, which will be the executable). - ArgStringList Arguments; + llvm::opt::ArgStringList Arguments; public: Command(const Action &_Source, const Tool &_Creator, const char *_Executable, - const ArgStringList &_Arguments); + const llvm::opt::ArgStringList &_Arguments); + + virtual void Print(llvm::raw_ostream &OS, const char *Terminator, + bool Quote, bool CrashReport = false) const; + + virtual int Execute(const StringRef **Redirects, std::string *ErrMsg, + bool *ExecutionFailed) const; /// getSource - Return the Action which caused the creation of this job. const Action &getSource() const { return Source; } @@ -69,16 +88,37 @@ public: /// getCreator - Return the Tool which caused the creation of this job. const Tool &getCreator() const { return Creator; } - const char *getExecutable() const { return Executable; } + const llvm::opt::ArgStringList &getArguments() const { return Arguments; } - const ArgStringList &getArguments() const { return Arguments; } + static bool classof(const Job *J) { + return J->getKind() == CommandClass || + J->getKind() == FallbackCommandClass; + } +}; + +/// Like Command, but with a fallback which is executed in case +/// the primary command crashes. +class FallbackCommand : public Command { +public: + FallbackCommand(const Action &Source_, const Tool &Creator_, + const char *Executable_, const ArgStringList &Arguments_, + Command *Fallback_); + + virtual void Print(llvm::raw_ostream &OS, const char *Terminator, + bool Quote, bool CrashReport = false) const; + + virtual int Execute(const StringRef **Redirects, std::string *ErrMsg, + bool *ExecutionFailed) const; static bool classof(const Job *J) { - return J->getKind() == CommandClass; + return J->getKind() == FallbackCommandClass; } + +private: + OwningPtr<Command> Fallback; }; - /// JobList - A sequence of jobs to perform. +/// JobList - A sequence of jobs to perform. class JobList : public Job { public: typedef SmallVector<Job*, 4> list_type; @@ -93,6 +133,9 @@ public: JobList(); virtual ~JobList(); + virtual void Print(llvm::raw_ostream &OS, const char *Terminator, + bool Quote, bool CrashReport = false) const; + /// Add a job to the list (taking ownership). void addJob(Job *J) { Jobs.push_back(J); } diff --git a/include/clang/Driver/Makefile b/include/clang/Driver/Makefile index 7d066c7..77cf6ff 100644 --- a/include/clang/Driver/Makefile +++ b/include/clang/Driver/Makefile @@ -5,10 +5,10 @@ TABLEGEN_INC_FILES_COMMON = 1 include $(CLANG_LEVEL)/Makefile -$(ObjDir)/Options.inc.tmp : Options.td CC1Options.td OptParser.td $(CLANG_TBLGEN) $(ObjDir)/.dir +$(ObjDir)/Options.inc.tmp : Options.td CC1Options.td CLCompatOptions.td $(LLVM_TBLGEN) $(ObjDir)/.dir $(Echo) "Building Clang Driver Option tables with tblgen" - $(Verb) $(ClangTableGen) -gen-opt-parser-defs -o $(call SYSPATH, $@) $< + $(Verb) $(LLVMTableGen) -gen-opt-parser-defs -o $(call SYSPATH, $@) $< -$(ObjDir)/CC1AsOptions.inc.tmp : CC1AsOptions.td OptParser.td $(CLANG_TBLGEN) $(ObjDir)/.dir +$(ObjDir)/CC1AsOptions.inc.tmp : CC1AsOptions.td $(LLVM_TBLGEN) $(ObjDir)/.dir $(Echo) "Building Clang CC1 Assembler Option tables with tblgen" - $(Verb) $(ClangTableGen) -gen-opt-parser-defs -o $(call SYSPATH, $@) $< + $(Verb) $(LLVMTableGen) -gen-opt-parser-defs -o $(call SYSPATH, $@) $< diff --git a/include/clang/Driver/OptParser.td b/include/clang/Driver/OptParser.td deleted file mode 100644 index d16a2a7..0000000 --- a/include/clang/Driver/OptParser.td +++ /dev/null @@ -1,152 +0,0 @@ -//===--- OptParser.td - Common Option Parsing Interfaces ------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the common interfaces used by the option parsing TableGen -// backend. -// -//===----------------------------------------------------------------------===// - -// Define the kinds of options. - -class OptionKind<string name, int predecence = 0, bit sentinel = 0> { - string Name = name; - // The kind precedence, kinds with lower precedence are matched first. - int Precedence = predecence; - // Indicate a sentinel option. - bit Sentinel = sentinel; -} - -// An option group. -def KIND_GROUP : OptionKind<"Group">; -// The input option kind. -def KIND_INPUT : OptionKind<"Input", 1, 1>; -// The unknown option kind. -def KIND_UNKNOWN : OptionKind<"Unknown", 2, 1>; -// A flag with no values. -def KIND_FLAG : OptionKind<"Flag">; -// An option which prefixes its (single) value. -def KIND_JOINED : OptionKind<"Joined", 1>; -// An option which is followed by its value. -def KIND_SEPARATE : OptionKind<"Separate">; -// An option followed by its values, which are separated by commas. -def KIND_COMMAJOINED : OptionKind<"CommaJoined">; -// An option which is which takes multiple (separate) arguments. -def KIND_MULTIARG : OptionKind<"MultiArg">; -// An option which is either joined to its (non-empty) value, or followed by its -// value. -def KIND_JOINED_OR_SEPARATE : OptionKind<"JoinedOrSeparate">; -// An option which is both joined to its (first) value, and followed by its -// (second) value. -def KIND_JOINED_AND_SEPARATE : OptionKind<"JoinedAndSeparate">; - -// Define the option flags. - -class OptionFlag {} - -// DriverOption - The option is a "driver" option, and should not be forwarded -// to gcc. -def DriverOption : OptionFlag; - -// LinkerInput - The option is a linker input. -def LinkerInput : OptionFlag; - -// NoArgumentUnused - Don't report argument unused warnings for this option; this -// is useful for options like -static or -dynamic which a user may always end up -// passing, even if the platform defaults to (or only supports) that option. -def NoArgumentUnused : OptionFlag; - -// RenderAsInput - The option should not render the name when rendered as an -// input (i.e., the option is rendered as values). -def RenderAsInput : OptionFlag; - -// RenderJoined - The option should be rendered joined, even if separate (only -// sensible on single value separate options). -def RenderJoined : OptionFlag; - -// RenderSeparate - The option should be rendered separately, even if joined -// (only sensible on joined options). -def RenderSeparate : OptionFlag; - -// Unsupported - The option is unsupported, and the driver will reject command -// lines that use it. -def Unsupported : OptionFlag; - -// HelpHidden - The option should not be displayed in --help, even if it has -// help text. Clients *can* use this in conjunction with the OptTable::PrintHelp -// arguments to implement hidden help groups. -def HelpHidden : OptionFlag; - -// NoForward - The option should not be implicitly forwarded to other tools. -def NoForward : OptionFlag; - -// CC1Option - This option should be accepted by clang -cc1. -def CC1Option : OptionFlag; - -// NoDriverOption - This option should not be accepted by the driver. -def NoDriverOption : OptionFlag; - -// Define the option group class. - -class OptionGroup<string name> { - string EnumName = ?; // Uses the def name if undefined. - string Name = name; - string HelpText = ?; - OptionGroup Group = ?; -} - -// Define the option class. - -class Option<list<string> prefixes, string name, OptionKind kind> { - string EnumName = ?; // Uses the def name if undefined. - list<string> Prefixes = prefixes; - string Name = name; - OptionKind Kind = kind; - // Used by MultiArg option kind. - int NumArgs = 0; - string HelpText = ?; - string MetaVarName = ?; - list<OptionFlag> Flags = []; - OptionGroup Group = ?; - Option Alias = ?; -} - -// Helpers for defining options. - -class Flag<list<string> prefixes, string name> - : Option<prefixes, name, KIND_FLAG>; -class Joined<list<string> prefixes, string name> - : Option<prefixes, name, KIND_JOINED>; -class Separate<list<string> prefixes, string name> - : Option<prefixes, name, KIND_SEPARATE>; -class CommaJoined<list<string> prefixes, string name> - : Option<prefixes, name, KIND_COMMAJOINED>; -class MultiArg<list<string> prefixes, string name, int numargs> - : Option<prefixes, name, KIND_MULTIARG> { - int NumArgs = numargs; -} -class JoinedOrSeparate<list<string> prefixes, string name> - : Option<prefixes, name, KIND_JOINED_OR_SEPARATE>; -class JoinedAndSeparate<list<string> prefixes, string name> - : Option<prefixes, name, KIND_JOINED_AND_SEPARATE>; - -// Mix-ins for adding optional attributes. - -class Alias<Option alias> { Option Alias = alias; } -class EnumName<string name> { string EnumName = name; } -class Flags<list<OptionFlag> flags> { list<OptionFlag> Flags = flags; } -class Group<OptionGroup group> { OptionGroup Group = group; } -class HelpText<string text> { string HelpText = text; } -class MetaVarName<string name> { string MetaVarName = name; } - -// Predefined options. - -// FIXME: Have generator validate that these appear in correct position (and -// aren't duplicated). -def INPUT : Option<[], "<input>", KIND_INPUT>, Flags<[DriverOption,CC1Option]>; -def UNKNOWN : Option<[], "<unknown>", KIND_UNKNOWN>; diff --git a/include/clang/Driver/OptSpecifier.h b/include/clang/Driver/OptSpecifier.h deleted file mode 100644 index e683ef3..0000000 --- a/include/clang/Driver/OptSpecifier.h +++ /dev/null @@ -1,41 +0,0 @@ -//===--- OptSpecifier.h - Option Specifiers ---------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef CLANG_DRIVER_OPTSPECIFIER_H -#define CLANG_DRIVER_OPTSPECIFIER_H - -#include "llvm/Support/Compiler.h" - -namespace clang { -namespace driver { - class Option; - - /// OptSpecifier - Wrapper class for abstracting references to option IDs. - class OptSpecifier { - unsigned ID; - - private: - explicit OptSpecifier(bool) LLVM_DELETED_FUNCTION; - - public: - OptSpecifier() : ID(0) {} - /*implicit*/ OptSpecifier(unsigned _ID) : ID(_ID) {} - /*implicit*/ OptSpecifier(const Option *Opt); - - bool isValid() const { return ID != 0; } - - unsigned getID() const { return ID; } - - bool operator==(OptSpecifier Opt) const { return ID == Opt.getID(); } - bool operator!=(OptSpecifier Opt) const { return !(*this == Opt); } - }; -} -} - -#endif diff --git a/include/clang/Driver/OptTable.h b/include/clang/Driver/OptTable.h deleted file mode 100644 index 53d83a0..0000000 --- a/include/clang/Driver/OptTable.h +++ /dev/null @@ -1,161 +0,0 @@ -//===--- OptTable.h - Option Table ------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef CLANG_DRIVER_OPTTABLE_H -#define CLANG_DRIVER_OPTTABLE_H - -#include "clang/Basic/LLVM.h" -#include "clang/Driver/OptSpecifier.h" -#include "llvm/ADT/StringSet.h" - -namespace clang { -namespace driver { - class Arg; - class ArgList; - class InputArgList; - class Option; - - /// \brief Provide access to the Option info table. - /// - /// The OptTable class provides a layer of indirection which allows Option - /// instance to be created lazily. In the common case, only a few options will - /// be needed at runtime; the OptTable class maintains enough information to - /// parse command lines without instantiating Options, while letting other - /// parts of the driver still use Option instances where convenient. - class OptTable { - public: - /// \brief Entry for a single option instance in the option data table. - struct Info { - /// A null terminated array of prefix strings to apply to name while - /// matching. - const char *const *Prefixes; - const char *Name; - const char *HelpText; - const char *MetaVar; - unsigned ID; - unsigned char Kind; - unsigned char Param; - unsigned short Flags; - unsigned short GroupID; - unsigned short AliasID; - }; - - private: - /// \brief The static option information table. - const Info *OptionInfos; - unsigned NumOptionInfos; - - unsigned TheInputOptionID; - unsigned TheUnknownOptionID; - - /// The index of the first option which can be parsed (i.e., is not a - /// special option like 'input' or 'unknown', and is not an option group). - unsigned FirstSearchableIndex; - - /// The union of all option prefixes. If an argument does not begin with - /// one of these, it is an input. - llvm::StringSet<> PrefixesUnion; - std::string PrefixChars; - - private: - const Info &getInfo(OptSpecifier Opt) const { - unsigned id = Opt.getID(); - assert(id > 0 && id - 1 < getNumOptions() && "Invalid Option ID."); - return OptionInfos[id - 1]; - } - - protected: - OptTable(const Info *_OptionInfos, unsigned _NumOptionInfos); - public: - ~OptTable(); - - /// \brief Return the total number of option classes. - unsigned getNumOptions() const { return NumOptionInfos; } - - /// \brief Get the given Opt's Option instance, lazily creating it - /// if necessary. - /// - /// \return The option, or null for the INVALID option id. - const Option getOption(OptSpecifier Opt) const; - - /// \brief Lookup the name of the given option. - const char *getOptionName(OptSpecifier id) const { - return getInfo(id).Name; - } - - /// \brief Get the kind of the given option. - unsigned getOptionKind(OptSpecifier id) const { - return getInfo(id).Kind; - } - - /// \brief Get the group id for the given option. - unsigned getOptionGroupID(OptSpecifier id) const { - return getInfo(id).GroupID; - } - - /// \brief Get the help text to use to describe this option. - const char *getOptionHelpText(OptSpecifier id) const { - return getInfo(id).HelpText; - } - - /// \brief Get the meta-variable name to use when describing - /// this options values in the help text. - const char *getOptionMetaVar(OptSpecifier id) const { - return getInfo(id).MetaVar; - } - - /// \brief Parse a single argument; returning the new argument and - /// updating Index. - /// - /// \param [in,out] Index - The current parsing position in the argument - /// string list; on return this will be the index of the next argument - /// string to parse. - /// - /// \return The parsed argument, or 0 if the argument is missing values - /// (in which case Index still points at the conceptual next argument string - /// to parse). - Arg *ParseOneArg(const ArgList &Args, unsigned &Index) const; - - /// \brief Parse an list of arguments into an InputArgList. - /// - /// The resulting InputArgList will reference the strings in [\p ArgBegin, - /// \p ArgEnd), and their lifetime should extend past that of the returned - /// InputArgList. - /// - /// The only error that can occur in this routine is if an argument is - /// missing values; in this case \p MissingArgCount will be non-zero. - /// - /// \param ArgBegin - The beginning of the argument vector. - /// \param ArgEnd - The end of the argument vector. - /// \param MissingArgIndex - On error, the index of the option which could - /// not be parsed. - /// \param MissingArgCount - On error, the number of missing options. - /// \return An InputArgList; on error this will contain all the options - /// which could be parsed. - InputArgList *ParseArgs(const char* const *ArgBegin, - const char* const *ArgEnd, - unsigned &MissingArgIndex, - unsigned &MissingArgCount) const; - - /// \brief Render the help text for an option table. - /// - /// \param OS - The stream to write the help text to. - /// \param Name - The name to use in the usage line. - /// \param Title - The title to use in the usage line. - /// \param FlagsToInclude - If non-zero, only include options with any - /// of these flags set. - /// \param FlagsToExclude - Exclude options with any of these flags set. - void PrintHelp(raw_ostream &OS, const char *Name, - const char *Title, unsigned short FlagsToInclude = 0, - unsigned short FlagsToExclude = 0) const; - }; -} -} - -#endif diff --git a/include/clang/Driver/Option.h b/include/clang/Driver/Option.h deleted file mode 100644 index 764934f..0000000 --- a/include/clang/Driver/Option.h +++ /dev/null @@ -1,204 +0,0 @@ -//===--- Option.h - Abstract Driver Options ---------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef CLANG_DRIVER_OPTION_H_ -#define CLANG_DRIVER_OPTION_H_ - -#include "clang/Basic/LLVM.h" -#include "clang/Driver/OptTable.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/ErrorHandling.h" - -namespace clang { -namespace driver { - class Arg; - class ArgList; - -namespace options { - /// Base flags for all options. Custom flags may be added after. - enum DriverFlag { - HelpHidden = (1 << 0), - RenderAsInput = (1 << 1), - RenderJoined = (1 << 2), - RenderSeparate = (1 << 3) - }; - - /// Flags specifically for clang options. - enum ClangFlags { - DriverOption = (1 << 4), - LinkerInput = (1 << 5), - NoArgumentUnused = (1 << 6), - NoForward = (1 << 7), - Unsupported = (1 << 8), - CC1Option = (1 << 9), - NoDriverOption = (1 << 10) - }; -} - - /// Option - Abstract representation for a single form of driver - /// argument. - /// - /// An Option class represents a form of option that the driver - /// takes, for example how many arguments the option has and how - /// they can be provided. Individual option instances store - /// additional information about what group the option is a member - /// of (if any), if the option is an alias, and a number of - /// flags. At runtime the driver parses the command line into - /// concrete Arg instances, each of which corresponds to a - /// particular Option instance. - class Option { - public: - enum OptionClass { - GroupClass = 0, - InputClass, - UnknownClass, - FlagClass, - JoinedClass, - SeparateClass, - CommaJoinedClass, - MultiArgClass, - JoinedOrSeparateClass, - JoinedAndSeparateClass - }; - - enum RenderStyleKind { - RenderCommaJoinedStyle, - RenderJoinedStyle, - RenderSeparateStyle, - RenderValuesStyle - }; - - protected: - const OptTable::Info *Info; - const OptTable *Owner; - - public: - Option(const OptTable::Info *Info, const OptTable *Owner); - ~Option(); - - bool isValid() const { - return Info != 0; - } - - unsigned getID() const { - assert(Info && "Must have a valid info!"); - return Info->ID; - } - - OptionClass getKind() const { - assert(Info && "Must have a valid info!"); - return OptionClass(Info->Kind); - } - - /// \brief Get the name of this option without any prefix. - StringRef getName() const { - assert(Info && "Must have a valid info!"); - return Info->Name; - } - - const Option getGroup() const { - assert(Info && "Must have a valid info!"); - assert(Owner && "Must have a valid owner!"); - return Owner->getOption(Info->GroupID); - } - - const Option getAlias() const { - assert(Info && "Must have a valid info!"); - assert(Owner && "Must have a valid owner!"); - return Owner->getOption(Info->AliasID); - } - - /// \brief Get the default prefix for this option. - StringRef getPrefix() const { - const char *Prefix = *Info->Prefixes; - return Prefix ? Prefix : StringRef(); - } - - /// \brief Get the name of this option with the default prefix. - std::string getPrefixedName() const { - std::string Ret = getPrefix(); - Ret += getName(); - return Ret; - } - - unsigned getNumArgs() const { return Info->Param; } - - bool hasNoOptAsInput() const { return Info->Flags & options::RenderAsInput;} - - RenderStyleKind getRenderStyle() const { - if (Info->Flags & options::RenderJoined) - return RenderJoinedStyle; - if (Info->Flags & options::RenderSeparate) - return RenderSeparateStyle; - switch (getKind()) { - case GroupClass: - case InputClass: - case UnknownClass: - return RenderValuesStyle; - case JoinedClass: - case JoinedAndSeparateClass: - return RenderJoinedStyle; - case CommaJoinedClass: - return RenderCommaJoinedStyle; - case FlagClass: - case SeparateClass: - case MultiArgClass: - case JoinedOrSeparateClass: - return RenderSeparateStyle; - } - llvm_unreachable("Unexpected kind!"); - } - - /// Test if this option has the flag \a Val. - bool hasFlag(unsigned Val) const { - return Info->Flags & Val; - } - - /// getUnaliasedOption - Return the final option this option - /// aliases (itself, if the option has no alias). - const Option getUnaliasedOption() const { - const Option Alias = getAlias(); - if (Alias.isValid()) return Alias.getUnaliasedOption(); - return *this; - } - - /// getRenderName - Return the name to use when rendering this - /// option. - StringRef getRenderName() const { - return getUnaliasedOption().getName(); - } - - /// matches - Predicate for whether this option is part of the - /// given option (which may be a group). - /// - /// Note that matches against options which are an alias should never be - /// done -- aliases do not participate in matching and so such a query will - /// always be false. - bool matches(OptSpecifier ID) const; - - /// accept - Potentially accept the current argument, returning a - /// new Arg instance, or 0 if the option does not accept this - /// argument (or the argument is missing values). - /// - /// If the option accepts the current argument, accept() sets - /// Index to the position where argument parsing should resume - /// (even if the argument is missing values). - /// - /// \parm ArgSize The number of bytes taken up by the matched Option prefix - /// and name. This is used to determine where joined values - /// start. - Arg *accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const; - - void dump() const; - }; - -} // end namespace driver -} // end namespace clang - -#endif diff --git a/include/clang/Driver/Options.h b/include/clang/Driver/Options.h index 6c114e2..28948be 100644 --- a/include/clang/Driver/Options.h +++ b/include/clang/Driver/Options.h @@ -10,24 +10,40 @@ #ifndef CLANG_DRIVER_OPTIONS_H #define CLANG_DRIVER_OPTIONS_H +namespace llvm { +namespace opt { +class OptTable; +} +} + namespace clang { namespace driver { - class OptTable; namespace options { - enum ID { +/// Flags specifically for clang options. Must not overlap with +/// llvm::opt::DriverFlag. +enum ClangFlags { + DriverOption = (1 << 4), + LinkerInput = (1 << 5), + NoArgumentUnused = (1 << 6), + Unsupported = (1 << 7), + CoreOption = (1 << 8), + CLOption = (1 << 9), + CC1Option = (1 << 10), + NoDriverOption = (1 << 11) +}; + +enum ID { OPT_INVALID = 0, // This is not an option ID. -#define PREFIX(NAME, VALUE) -#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, FLAGS, PARAM, \ +#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ HELPTEXT, METAVAR) OPT_##ID, #include "clang/Driver/Options.inc" LastOption #undef OPTION -#undef PREFIX }; } - OptTable *createDriverOptTable(); +llvm::opt::OptTable *createDriverOptTable(); } } diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td index 3a5358a..9e7dc78 100644 --- a/include/clang/Driver/Options.td +++ b/include/clang/Driver/Options.td @@ -12,23 +12,55 @@ //===----------------------------------------------------------------------===// // Include the common option parsing interfaces. -include "OptParser.td" +include "llvm/Option/OptParser.td" + +///////// +// Flags + +// DriverOption - The option is a "driver" option, and should not be forwarded +// to other tools. +def DriverOption : OptionFlag; + +// LinkerInput - The option is a linker input. +def LinkerInput : OptionFlag; + +// NoArgumentUnused - Don't report argument unused warnings for this option; this +// is useful for options like -static or -dynamic which a user may always end up +// passing, even if the platform defaults to (or only supports) that option. +def NoArgumentUnused : OptionFlag; + +// Unsupported - The option is unsupported, and the driver will reject command +// lines that use it. +def Unsupported : OptionFlag; + +// CoreOption - This is considered a "core" Clang option, available in both +// clang and clang-cl modes. +def CoreOption : OptionFlag; + +// CLOption - This is a cl.exe compatibility option. Options with this flag +// are made available when the driver is running in CL compatibility mode. +def CLOption : OptionFlag; + +// CC1Option - This option should be accepted by clang -cc1. +def CC1Option : OptionFlag; + +// NoDriverOption - This option should not be accepted by the driver. +def NoDriverOption : OptionFlag; ///////// // Groups -// Meta-group which defines +// Meta-group for options which are only used for compilation, +// and not linking etc. def CompileOnly_Group : OptionGroup<"<CompileOnly group>">; + def Action_Group : OptionGroup<"<action group>">; def I_Group : OptionGroup<"<I group>">, Group<CompileOnly_Group>; -def L_Group : OptionGroup<"<L group>">, Group<CompileOnly_Group>; def M_Group : OptionGroup<"<M group>">, Group<CompileOnly_Group>; def T_Group : OptionGroup<"<T group>">; def O_Group : OptionGroup<"<O group>">, Group<CompileOnly_Group>; def W_Group : OptionGroup<"<W group>">, Group<CompileOnly_Group>; -def X_Group : OptionGroup<"<X group>">; -def a_Group : OptionGroup<"<a group>">; def d_Group : OptionGroup<"<d group>">; def f_Group : OptionGroup<"<f group>">, Group<CompileOnly_Group>; def f_clang_Group : OptionGroup<"<f (clang-only) group>">, Group<CompileOnly_Group>; @@ -39,10 +71,10 @@ def clang_i_Group : OptionGroup<"<clang i group>">, Group<i_Group>; def m_Group : OptionGroup<"<m group>">, Group<CompileOnly_Group>; def m_x86_Features_Group : OptionGroup<"<m x86 features group>">, Group<m_Group>; def m_hexagon_Features_Group : OptionGroup<"<m hexagon features group>">, Group<m_Group>; +def m_arm_Features_Group : OptionGroup<"<m arm features group>">, Group<m_Group>; +def m_ppc_Features_Group : OptionGroup<"<m ppc features group>">, Group<m_Group>; def opencl_Group : OptionGroup<"<opencl group>">; def u_Group : OptionGroup<"<u group>">; -def mips_CPUs_Group : OptionGroup<"<MIPS CPU aliases group>">, - Group<CompileOnly_Group>; def pedantic_Group : OptionGroup<"<pedantic group>">, Group<CompileOnly_Group>; @@ -69,7 +101,9 @@ def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">, // substitutions: // _ => __ // - => _ +// / => _SLASH // # => _HASH +// ? => _QUESTION // , => _COMMA // = => _EQ // C++ => CXX @@ -77,45 +111,40 @@ def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">, // Developer Driver Options -def ccc_Group : OptionGroup<"<clang internal options>">; -def ccc_driver_Group : OptionGroup<"<clang driver internal options>">, - Group<ccc_Group>, HelpText<"DRIVER OPTIONS">; -def ccc_debug_Group : OptionGroup<"<clang debug/development internal options>">, - Group<ccc_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">; - -class CCCDriverOpt : Group<ccc_driver_Group>, Flags<[DriverOption, HelpHidden]>; -def ccc_cxx : Flag<["-"], "ccc-cxx">, CCCDriverOpt, - HelpText<"Act as a C++ driver">; -def ccc_echo : Flag<["-"], "ccc-echo">, CCCDriverOpt, - HelpText<"Echo commands before running them">; -def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, CCCDriverOpt, +def internal_Group : OptionGroup<"<clang internal options>">; +def internal_driver_Group : OptionGroup<"<clang driver internal options>">, + Group<internal_Group>, HelpText<"DRIVER OPTIONS">; +def internal_debug_Group : + OptionGroup<"<clang debug/development internal options>">, + Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">; + +class InternalDriverOpt : Group<internal_driver_Group>, + Flags<[DriverOption, HelpHidden]>; +def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>, + Flags<[CoreOption, DriverOption, HelpHidden]>, + HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">; +def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt, HelpText<"Name for native GCC compiler">, MetaVarName<"<gcc-path>">; -def ccc_clang_archs : Separate<["-"], "ccc-clang-archs">, CCCDriverOpt, - HelpText<"Comma separate list of architectures to use the clang compiler for">, - MetaVarName<"<arch-list>">; -def ccc_pch_is_pch : Flag<["-"], "ccc-pch-is-pch">, CCCDriverOpt, +def ccc_pch_is_pch : Flag<["-"], "ccc-pch-is-pch">, InternalDriverOpt, HelpText<"Use lazy PCH for precompiled headers">; -def ccc_pch_is_pth : Flag<["-"], "ccc-pch-is-pth">, CCCDriverOpt, +def ccc_pch_is_pth : Flag<["-"], "ccc-pch-is-pth">, InternalDriverOpt, HelpText<"Use pretokenized headers for precompiled headers">; -class CCCDebugOpt : Group<ccc_debug_Group>, Flags<[DriverOption, HelpHidden]>; -def ccc_install_dir : Separate<["-"], "ccc-install-dir">, CCCDebugOpt, +class InternalDebugOpt : Group<internal_debug_Group>, + Flags<[DriverOption, HelpHidden]>; +def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt, HelpText<"Simulate installation in the given directory">; -def ccc_print_options : Flag<["-"], "ccc-print-options">, CCCDebugOpt, - HelpText<"Dump parsed command line arguments">; -def ccc_print_phases : Flag<["-"], "ccc-print-phases">, CCCDebugOpt, +def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt, HelpText<"Dump list of actions to perform">; -def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, CCCDebugOpt, +def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt, HelpText<"Show bindings of tools to actions">; -def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, CCCDriverOpt, +def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt, HelpText<"Check for ARC migration issues that need manual handling">; -def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, CCCDriverOpt, +def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt, HelpText<"Apply modifications to files to conform to ARC">; -def ccc_arrmt_check : Flag<["-"], "ccc-arrmt-check">, Alias<ccc_arcmt_check>; -def ccc_arrmt_modify : Flag<["-"], "ccc-arrmt-modify">, Alias<ccc_arcmt_modify>; -def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, CCCDriverOpt, +def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, InternalDriverOpt, HelpText<"Apply modifications and produces temporary files that conform to ARC">; def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">, HelpText<"Output path for the plist report">, Flags<[CC1Option]>; @@ -125,25 +154,49 @@ def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">, def _migrate : Flag<["--"], "migrate">, Flags<[DriverOption]>, HelpText<"Run the migrator">; -def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">, CCCDriverOpt, +def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">, + InternalDriverOpt, HelpText<"Apply modifications and produces temporary files to migrate to " "modern ObjC syntax">; def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>, HelpText<"Enable migration to modern ObjC literals">; def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>, HelpText<"Enable migration to modern ObjC subscripting">; +def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>, + HelpText<"Enable migration to modern ObjC property">; +def objcmt_migrate_all : Flag<["-"], "objcmt-migrate-all">, Flags<[CC1Option]>, + HelpText<"Enable migration to modern ObjC">; +def objcmt_migrate_readonly_property : Flag<["-"], "objcmt-migrate-readonly-property">, Flags<[CC1Option]>, + HelpText<"Enable migration to modern ObjC readonly property">; +def objcmt_migrate_readwrite_property : Flag<["-"], "objcmt-migrate-readwrite-property">, Flags<[CC1Option]>, + HelpText<"Enable migration to modern ObjC readwrite property">; +def objcmt_migrate_annotation : Flag<["-"], "objcmt-migrate-annotation">, Flags<[CC1Option]>, + HelpText<"Enable migration to property and method annotations">; +def objcmt_migrate_instancetype : Flag<["-"], "objcmt-migrate-instancetype">, Flags<[CC1Option]>, + HelpText<"Enable migration to infer instancetype for method result type">; +def objcmt_migrate_nsmacros : Flag<["-"], "objcmt-migrate-ns-macros">, Flags<[CC1Option]>, + HelpText<"Enable migration to NS_ENUM/NS_OPTIONS macros">; +def objcmt_migrate_protocol_conformance : Flag<["-"], "objcmt-migrate-protocol-conformance">, Flags<[CC1Option]>, + HelpText<"Enable migration to add protocol conformance on classes">; +def objcmt_atomic_property : Flag<["-"], "objcmt-atomic-property">, Flags<[CC1Option]>, + HelpText<"Make migration to 'atomic' properties">; +def objcmt_returns_innerpointer_property : Flag<["-"], "objcmt-returns-innerpointer-property">, Flags<[CC1Option]>, + HelpText<"Enable migration to annotate property with NS_RETURNS_INNER_POINTER">; +def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>, + HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">; +def objcmt_white_list_dir_path: Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>, + HelpText<"Only modify files with a filename contained in the provided directory path">; // Make sure all other -ccc- options are rejected. -def ccc_ : Joined<["-"], "ccc-">, Group<ccc_Group>, Flags<[Unsupported]>; +def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>; // Standard Options -def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption]>, +def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>, HelpText<"Print the commands to run for this compilation">; -// The '--' option is here for the sake of compatibility with gcc, but is -// being ignored by the driver. -def _DASH_DASH : Flag<["--"], "">, Flags<[DriverOption]>; -def A : JoinedOrSeparate<["-"], "A">; +def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>, + Flags<[DriverOption, CoreOption]>; +def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>; def B : JoinedOrSeparate<["-"], "B">; def CC : Flag<["-"], "CC">, Flags<[CC1Option]>; def C : Flag<["-"], "C">, Flags<[CC1Option]>; @@ -174,18 +227,19 @@ def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>, HelpText<"Specify target for dependency">; def Mach : Flag<["-"], "Mach">; def M : Flag<["-"], "M">, Group<M_Group>; -def O0 : Joined<["-"], "O0">, Group<O_Group>, Flags<[CC1Option]>; -def O4 : Joined<["-"], "O4">, Group<O_Group>, Flags<[CC1Option]>; +def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option]>; +def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option]>; def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>, HelpText<"Treat source input files as Objective-C++ inputs">; def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>, HelpText<"Treat source input files as Objective-C inputs">; def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>; +def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["2"]>; def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>; def P : Flag<["-"], "P">, Flags<[CC1Option]>, HelpText<"Disable linemarker output in -E mode">; def Qn : Flag<["-"], "Qn">; -def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption]>, +def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>, HelpText<"Don't emit warning for unused driver arguments">; def Q : Flag<["-"], "Q">; def R : Flag<["-"], "R">; @@ -214,9 +268,7 @@ def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Gr def Wp_COMMA : CommaJoined<["-"], "Wp,">, HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">, MetaVarName<"<arg>">; -def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option]>; -def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option]>; -def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option]>, +def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<warning>">, HelpText<"Enable the specified warning">; def Xanalyzer : Separate<["-"], "Xanalyzer">, HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">; @@ -225,7 +277,7 @@ def Xassembler : Separate<["-"], "Xassembler">, HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">; def Xclang : Separate<["-"], "Xclang">, HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">, - Flags<[NoForward]>; + Flags<[DriverOption, CoreOption]>; def Xlinker : Separate<["-"], "Xlinker">, Flags<[LinkerInput, RenderAsInput]>, HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">; def Xpreprocessor : Separate<["-"], "Xpreprocessor">, @@ -236,11 +288,11 @@ def Z_Flag : Flag<["-"], "Z">; def Z_Joined : Joined<["-"], "Z">; def all__load : Flag<["-"], "all_load">; def allowable__client : Separate<["-"], "allowable_client">; -def ansi : Flag<["-", "--"], "ansi">, Group<a_Group>; +def ansi : Flag<["-", "--"], "ansi">; def arch__errors__fatal : Flag<["-"], "arch_errors_fatal">; def arch : Separate<["-"], "arch">, Flags<[DriverOption]>; def arch__only : Separate<["-"], "arch_only">; -def a : Joined<["-"], "a">, Group<a_Group>; +def a : Joined<["-"], "a">; def bind__at__load : Flag<["-"], "bind_at_load">; def bundle__loader : Separate<["-"], "bundle_loader">; def bundle : Flag<["-"], "bundle">; @@ -290,9 +342,6 @@ def fPIE : Flag<["-"], "fPIE">, Group<f_Group>; def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>; def faccess_control : Flag<["-"], "faccess-control">, Group<f_Group>; def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>; -def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Enable AltiVec vector initializer syntax">; -def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[CC1Option]>; def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Use Apple's kernel extensions ABI">; def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>, @@ -313,9 +362,14 @@ def fast : Flag<["-"], "fast">, Group<f_Group>; def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>; def fautolink : Flag <["-"], "fautolink">, Group<f_Group>; -def fno_autolink : Flag <["-"], "fno-autolink">, Group<f_Group>, Flags<[NoForward, CC1Option]>, +def fno_autolink : Flag <["-"], "fno-autolink">, Group<f_Group>, + Flags<[DriverOption, CC1Option]>, HelpText<"Disable generation of linker directives for automatic library linking">; +def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">, + Group<f_Group>, Flags<[DriverOption, CC1Option]>, + HelpText<"Enable sample-based profile guided optimizations">; + def fblocks : Flag<["-"], "fblocks">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable the 'blocks' language feature">; def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>; @@ -325,8 +379,6 @@ def fbounds_checking : Flag<["-"], "fbounds-checking">, Group<f_Group>, HelpText<"Enable run-time bounds checks">; def fbounds_checking_EQ : Joined<["-"], "fbounds-checking=">, Flags<[CC1Option]>, Group<f_Group>; -def fbuiltin_strcat : Flag<["-"], "fbuiltin-strcat">, Group<f_Group>; -def fbuiltin_strcpy : Flag<["-"], "fbuiltin-strcpy">, Group<f_Group>; def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>; def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group<f_Group>; def fcatch_undefined_behavior : Flag<["-"], "fcatch-undefined-behavior">, Group<f_Group>; @@ -335,6 +387,8 @@ def fcolor_diagnostics : Flag<["-"], "fcolor-diagnostics">, Group<f_Group>, Flag HelpText<"Use colors in diagnostics">; def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>; def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>; +def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Use ANSI escape codes for diagnostics">; def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>, HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">, MetaVarName<"<arg>">; @@ -344,13 +398,15 @@ def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>; def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>; def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>; def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>; +def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>; def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">, Group<f_Group>; def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused]>; def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>; def fcxx_exceptions: Flag<["-"], "fcxx-exceptions">, Group<f_Group>, HelpText<"Enable C++ exceptions">, Flags<[CC1Option]>; -def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>, Flags<[NoForward]>; +def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>, + Flags<[DriverOption]>; def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>; def fdebug_pass_structure : Flag<["-"], "fdebug-pass-structure">, Group<f_Group>; def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>; @@ -387,6 +443,10 @@ def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>; def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>; def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable support for exception handling">; +def fexpensive_optimizations : Flag<["-"], "fexpensive-optimizations">, + Group<clang_ignored_f_Group>; +def fno_expensive_optimizations : Flag<["-"], "fno-expensive-optimizations">, + Group<clang_ignored_f_Group>; def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>; def fextended_identifiers : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>; @@ -405,7 +465,7 @@ def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>; def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>; def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>; def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>, - Flags<[CC1Option]>, MetaVarName<"<check>">, + Flags<[CC1Option, CoreOption]>, MetaVarName<"<check>">, HelpText<"Enable runtime instrumentation for bug detection: " "address (memory errors) | thread (race detection) | " "undefined (miscellaneous undefined behavior)">; @@ -500,13 +560,13 @@ def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Op HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">; def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Enable Microsoft compatibility mode">; -def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[CC1Option]>, +def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, HelpText<"Version of the Microsoft C/C++ compiler to report in _MSC_VER (0 = don't define it (default))">; def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>, HelpText<"Parse templated function definitions at the end of the " "translation unit ">, Flags<[CC1Option]>; def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>, - Flags<[NoForward,CC1Option]>, MetaVarName<"<directory>">, + Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">, HelpText<"Specify the module cache path">; def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<seconds>">, @@ -514,10 +574,23 @@ def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<seconds>">, HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">; -def fmodules : Flag <["-"], "fmodules">, Group<f_Group>, Flags<[NoForward,CC1Option]>, +def fmodules : Flag <["-"], "fmodules">, Group<f_Group>, + Flags<[DriverOption, CC1Option]>, HelpText<"Enable the 'modules' language feature">; +def fmodule_maps : Flag <["-"], "fmodule-maps">, Group<f_Group>, + Flags<[DriverOption,CC1Option]>, + HelpText<"Read module maps to understand the structure of library headers">; +def fmodule_name : JoinedOrSeparate<["-"], "fmodule-name=">, Group<f_Group>, + Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">, + HelpText<"Specify the name of the module to build">; +def fmodule_map_file : JoinedOrSeparate<["-"], "fmodule-map-file=">, + Group<f_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"<file>">, + HelpText<"Load this module map file">; def fmodules_ignore_macro : Joined<["-"], "fmodules-ignore-macro=">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Ignore the definition of the given macro when building and loading modules">; +def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>, + Flags<[DriverOption,CC1Option]>, + HelpText<"Require declaration of modules used within a module">; def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>; def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>; @@ -534,10 +607,12 @@ def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Flags<[CC1Option]>; def fno_blocks : Flag<["-"], "fno-blocks">, Group<f_Group>; def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>; -def fno_builtin_strcat : Flag<["-"], "fno-builtin-strcat">, Group<f_Group>; -def fno_builtin_strcpy : Flag<["-"], "fno-builtin-strcpy">, Group<f_Group>; def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Disable implicit builtin knowledge of functions">; +def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<clang_ignored_f_Group>, + HelpText<"Disable implicit builtin knowledge of a specific function">; +def fno_math_builtin : Flag<["-"], "fno-math-builtin">, Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Disable implicit builtin knowledge of math functions">; def fno_caret_diagnostics : Flag<["-"], "fno-caret-diagnostics">, Group<f_Group>, Flags<[CC1Option]>; def fno_color_diagnostics : Flag<["-"], "fno-color-diagnostics">, Group<f_Group>; @@ -548,13 +623,14 @@ def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Grou Flags<[CC1Option]>, HelpText<"Disable creation of CodeFoundation-type constant strings">; def fno_cxx_exceptions: Flag<["-"], "fno-cxx-exceptions">, Group<f_Group>; -def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>, Flags<[NoForward]>; +def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>, + Flags<[DriverOption]>; def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">; def fno_diagnostics_show_name : Flag<["-"], "fno-diagnostics-show-name">, Group<f_Group>; def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>; def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">, - Flags<[CC1Option]>, Group<f_Group>, HelpText<"Display include stacks for diagnostic notes">; + Flags<[CC1Option]>, Group<f_Group>; def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>, HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>; def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>, @@ -571,7 +647,12 @@ def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Group<f_Group>, HelpText<"Do not limit debug information produced to reduce size of debug binary">; def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Disallow merging of constants">; -def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, Flags<[NoForward]>; +def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, + Flags<[DriverOption]>; +def fno_module_maps : Flag <["-"], "fno-module-maps">, Group<f_Group>, + Flags<[DriverOption]>; +def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>, + Flags<[DriverOption]>; def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>; def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>; def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>; @@ -594,6 +675,7 @@ def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>, def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>; def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>; def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>; +def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>; def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>; def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>; def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>, @@ -643,7 +725,6 @@ def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>; def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>; def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>; -def fobjc : Flag<["-"], "fobjc">, Group<f_Group>; def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>; def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option]>; def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>; @@ -658,6 +739,8 @@ def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1 HelpText<"Specify the default maximum struct packing alignment">; def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Recognize and construct Pascal-style string literals">; +def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Override the default ABI to return all structs on the stack">; def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>; def fpic : Flag<["-"], "fpic">, Group<f_Group>; def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>; @@ -667,6 +750,8 @@ def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>; def fprofile_generate : Flag<["-"], "fprofile-generate">, Group<f_Group>; def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>; def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>; +def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Override the default ABI to return small structs in registers">; def frtti : Flag<["-"], "frtti">, Group<f_Group>; def fsched_interblock : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>; def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>, @@ -682,6 +767,8 @@ def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group> def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>; def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>; def fsigned_char : Flag<["-"], "fsigned-char">, Group<f_Group>; +def fno_signed_char : Flag<["-"], "fno-signed-char">, Flags<[CC1Option]>, + Group<clang_ignored_f_Group>, HelpText<"Char is unsigned">; def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>; def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>; def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>; @@ -696,6 +783,8 @@ def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>; def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>; def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">, Group<f_Group>; +def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">, + Group<f_Group>; def ftest_coverage : Flag<["-"], "ftest-coverage">, Group<f_Group>; def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>, HelpText<"Enable the loop vectorization passes">; @@ -737,12 +826,21 @@ def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags< def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>; def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>, HelpText<"Turn on loop unroller">, Flags<[CC1Option]>; +def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>, + HelpText<"Turn off loop unroller">, Flags<[CC1Option]>; +def freroll_loops : Flag<["-"], "freroll-loops">, Group<f_Group>, + HelpText<"Turn on loop reroller">, Flags<[CC1Option]>; +def fno_reroll_loops : Flag<["-"], "fno-reroll-loops">, Group<f_Group>, + HelpText<"Turn off loop reroller">; def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>; def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>; +def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">, Group<clang_ignored_f_Group>; def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>; def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>; def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Use .init_array instead of .ctors">; +def fno_var_tracking : Flag<["-"], "fno-var-tracking">, + Group<clang_ignored_f_Group>; def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>; def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>, HelpText<"Set the default symbol visibility for all global declarations">; @@ -757,11 +855,17 @@ def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>, def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Store string literals as writable data">; def fzero_initialized_in_bss : Flag<["-"], "fzero-initialized-in-bss">, Group<f_Group>; -def ffunction_sections: Flag <["-"], "ffunction-sections">, Group<f_Group>, - Flags<[CC1Option]>, HelpText<"Place each function in its own section (ELF Only)">; -def fdata_sections : Flag <["-"], "fdata-sections">, Group<f_Group>, Flags<[CC1Option]>, - HelpText<"Place each data in its own section (ELF Only)">; -def f : Joined<["-"], "f">, Group<f_Group>; +def ffunction_sections : Flag<["-"], "ffunction-sections">, Group<f_Group>, + Flags<[CC1Option]>, + HelpText<"Place each function in its own section (ELF Only)">; +def fno_function_sections : Flag<["-"], "fno-function-sections">, + Group<f_Group>, Flags<[CC1Option]>; +def fdata_sections : Flag <["-"], "fdata-sections">, Group<f_Group>, + Flags<[CC1Option]>, HelpText<"Place each data in its own section (ELF Only)">; +def fno_data_sections : Flag <["-"], "fno-data-sections">, Group<f_Group>, + Flags<[CC1Option]>; +def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>, + Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">; def g_Flag : Flag<["-"], "g">, Group<g_Group>, HelpText<"Generate source level debug information">, Flags<[CC1Option]>; def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<g_Group>, @@ -775,9 +879,12 @@ def ggdb0 : Flag<["-"], "ggdb0">, Group<g_Group>; def ggdb1 : Flag<["-"], "ggdb1">, Group<g_Group>; def ggdb2 : Flag<["-"], "ggdb2">, Group<g_Group>; def ggdb3 : Flag<["-"], "ggdb3">, Group<g_Group>; -def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>; -def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>; -def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>; +def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>, + HelpText<"Generate source level debug information with dwarf version 2">, Flags<[CC1Option]>; +def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>, + HelpText<"Generate source level debug information with dwarf version 3">, Flags<[CC1Option]>; +def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>, + HelpText<"Generate source level debug information with dwarf version 4">, Flags<[CC1Option]>; def gfull : Flag<["-"], "gfull">, Group<g_Group>; def gused : Flag<["-"], "gused">, Group<g_Group>; def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>; @@ -792,6 +899,7 @@ def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>; def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>; def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>; def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>; +def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>; def headerpad__max__install__names : Joined<["-"], "headerpad_max_install_names">; def help : Flag<["-", "--"], "help">, Flags<[CC1Option]>, HelpText<"Display available options">; @@ -808,6 +916,8 @@ def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, E MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>; def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>, HelpText<"Include precompiled header file">, MetaVarName<"<file>">; +def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>, + HelpText<"Whether to build a relocatable precompiled header">; def init : Separate<["-"], "init">; def install__name : Separate<["-"], "install_name">; def integrated_as : Flag<["-"], "integrated-as">, Flags<[DriverOption]>; @@ -835,39 +945,34 @@ def lazy__framework : Separate<["-"], "lazy_framework">, Flags<[LinkerInput]>; def lazy__library : Separate<["-"], "lazy_library">, Flags<[LinkerInput]>; def EL : Flag<["-"], "EL">, Flags<[DriverOption]>; def EB : Flag<["-"], "EB">, Flags<[DriverOption]>; -def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption]>; +def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>; def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption,CC1Option]>, HelpText<"Enable hexagon-qdsp6 backward compatibility">; def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>; def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>; -def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption]>; +def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption, CoreOption]>; def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>; def march_EQ : Joined<["-"], "march=">, Group<m_Group>; -def maltivec : Flag<["-"], "maltivec">, Alias<faltivec>; -def mno_altivec : Flag<["-"], "mno-altivec">, Alias<fno_altivec>; -def mfprnd : Flag<["-"], "mfprnd">, Group<m_Group>; -def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_Group>; -def mmfcrf : Flag<["-"], "mmfcrf">, Group<m_Group>; -def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Group<m_Group>; -def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_Group>; -def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_Group>; -def mqpx : Flag<["-"], "mqpx">, Group<m_Group>; -def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_Group>; def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>; def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>; def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>; def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>; def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>; +def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>; +def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>; +def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>; def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>; def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>; def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>; +def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>; def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>; def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>; def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_Group>; def mios_version_min_EQ : Joined<["-"], "mios-version-min=">, Alias<miphoneos_version_min_EQ>; def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">, Group<m_Group>; def mkernel : Flag<["-"], "mkernel">, Group<m_Group>; -def mlinker_version_EQ : Joined<["-"], "mlinker-version=">, Flags<[NoForward]>; +def mlinker_version_EQ : Joined<["-"], "mlinker-version=">, + Flags<[DriverOption]>; def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option]>, HelpText<"Additional arguments to forward to LLVM's option processing">; def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">, Group<m_Group>; @@ -877,8 +982,6 @@ def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Opti HelpText<"Force realign the stack at entry to every function">; def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"Set the stack alignment">; -def mstrict_align : Flag<["-"], "mstrict-align">, Group<m_Group>, Flags<[CC1Option]>, - HelpText<"Force all memory accesses to be aligned (ARM only)">; def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>; def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>; def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>; @@ -886,7 +989,8 @@ def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Grou def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>, HelpText<"Disable merging of globals">; def mno_mmx : Flag<["-"], "mno-mmx">, Group<m_x86_Features_Group>; -def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">, Group<m_Group>; +def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">, + Alias<fno_pascal_strings>; def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>; def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>; def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>; @@ -903,12 +1007,17 @@ def mno_ssse3 : Flag<["-"], "mno-ssse3">, Group<m_x86_Features_Group>; def mno_aes : Flag<["-"], "mno-aes">, Group<m_x86_Features_Group>; def mno_avx : Flag<["-"], "mno-avx">, Group<m_x86_Features_Group>; def mno_avx2 : Flag<["-"], "mno-avx2">, Group<m_x86_Features_Group>; +def mno_avx512f : Flag<["-"], "mno-avx512f">, Group<m_x86_Features_Group>; +def mno_avx512cd : Flag<["-"], "mno-avx512cd">, Group<m_x86_Features_Group>; +def mno_avx512er : Flag<["-"], "mno-avx512er">, Group<m_x86_Features_Group>; +def mno_avx512pf : Flag<["-"], "mno-avx512pf">, Group<m_x86_Features_Group>; def mno_pclmul : Flag<["-"], "mno-pclmul">, Group<m_x86_Features_Group>; def mno_lzcnt : Flag<["-"], "mno-lzcnt">, Group<m_x86_Features_Group>; def mno_rdrnd : Flag<["-"], "mno-rdrnd">, Group<m_x86_Features_Group>; def mno_bmi : Flag<["-"], "mno-bmi">, Group<m_x86_Features_Group>; def mno_bmi2 : Flag<["-"], "mno-bmi2">, Group<m_x86_Features_Group>; def mno_popcnt : Flag<["-"], "mno-popcnt">, Group<m_x86_Features_Group>; +def mno_tbm : Flag<["-"], "mno-tbm">, Group<m_x86_Features_Group>; def mno_fma4 : Flag<["-"], "mno-fma4">, Group<m_x86_Features_Group>; def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>; def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>; @@ -916,16 +1025,50 @@ def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>; def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>; def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>; def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>; +def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>; -def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_Group>; +def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>, + HelpText<"Allow memory accesses to be unaligned (ARM only)">; +def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>, + HelpText<"Force all memory accesses to be aligned (ARM only)">; +def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>, + HelpText<"Force all memory accesses to be aligned (ARM only, same as mno-unaligned-access)">; +def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>; +def mrestrict_it: Flag<["-"], "mrestrict-it">, Group<m_arm_Features_Group>, + HelpText<"Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.">; +def mno_restrict_it: Flag<["-"], "mno-restrict-it">, Group<m_arm_Features_Group>, + HelpText<"Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode">; def marm : Flag<["-"], "marm">, Alias<mno_thumb>; +def ffixed_r9 : Flag<["-"], "ffixed-r9">, Group<m_arm_Features_Group>, + HelpText<"Reserve the r9 register (ARM only)">; +def mcrc : Flag<["-"], "mcrc">, Group<m_arm_Features_Group>, + HelpText<"Allow use of CRC instructions (ARM only)">; +def mnocrc : Flag<["-"], "mnocrc">, Group<m_arm_Features_Group>, + HelpText<"Disallow use of CRC instructions (ARM only)">; + +def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>; +def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>; +def mfprnd : Flag<["-"], "mfprnd">, Group<m_ppc_Features_Group>; +def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_ppc_Features_Group>; +def mmfcrf : Flag<["-"], "mmfcrf">, Group<m_ppc_Features_Group>; +def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Group<m_ppc_Features_Group>; +def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_ppc_Features_Group>; +def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_ppc_Features_Group>; +def mqpx : Flag<["-"], "mqpx">, Group<m_ppc_Features_Group>; +def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_ppc_Features_Group>; + +def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Enable AltiVec vector initializer syntax">; +def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[CC1Option]>; +def maltivec : Flag<["-"], "maltivec">, Alias<faltivec>; +def mno_altivec : Flag<["-"], "mno-altivec">, Alias<fno_altivec>; def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>; def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>; def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>, HelpText<"Omit frame pointer setup for leaf functions">, Flags<[CC1Option]>; def moslib_EQ : Joined<["-"], "moslib=">, Group<m_Group>; -def mpascal_strings : Flag<["-"], "mpascal-strings">, Group<m_Group>; +def mpascal_strings : Flag<["-"], "mpascal-strings">, Alias<fpascal_strings>; def mred_zone : Flag<["-"], "mred-zone">, Group<m_Group>; def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>; def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option]>, @@ -949,12 +1092,17 @@ def mssse3 : Flag<["-"], "mssse3">, Group<m_x86_Features_Group>; def maes : Flag<["-"], "maes">, Group<m_x86_Features_Group>; def mavx : Flag<["-"], "mavx">, Group<m_x86_Features_Group>; def mavx2 : Flag<["-"], "mavx2">, Group<m_x86_Features_Group>; +def mavx512f : Flag<["-"], "mavx512f">, Group<m_x86_Features_Group>; +def mavx512cd : Flag<["-"], "mavx512cd">, Group<m_x86_Features_Group>; +def mavx512er : Flag<["-"], "mavx512er">, Group<m_x86_Features_Group>; +def mavx512pf : Flag<["-"], "mavx512pf">, Group<m_x86_Features_Group>; def mpclmul : Flag<["-"], "mpclmul">, Group<m_x86_Features_Group>; def mlzcnt : Flag<["-"], "mlzcnt">, Group<m_x86_Features_Group>; def mrdrnd : Flag<["-"], "mrdrnd">, Group<m_x86_Features_Group>; def mbmi : Flag<["-"], "mbmi">, Group<m_x86_Features_Group>; def mbmi2 : Flag<["-"], "mbmi2">, Group<m_x86_Features_Group>; def mpopcnt : Flag<["-"], "mpopcnt">, Group<m_x86_Features_Group>; +def mtbm : Flag<["-"], "mtbm">, Group<m_x86_Features_Group>; def mfma4 : Flag<["-"], "mfma4">, Group<m_x86_Features_Group>; def mfma : Flag<["-"], "mfma">, Group<m_x86_Features_Group>; def mxop : Flag<["-"], "mxop">, Group<m_x86_Features_Group>; @@ -962,25 +1110,45 @@ def mf16c : Flag<["-"], "mf16c">, Group<m_x86_Features_Group>; def mrtm : Flag<["-"], "mrtm">, Group<m_x86_Features_Group>; def mprfchw : Flag<["-"], "mprfchw">, Group<m_x86_Features_Group>; def mrdseed : Flag<["-"], "mrdseed">, Group<m_x86_Features_Group>; +def msha : Flag<["-"], "msha">, Group<m_x86_Features_Group>; +def mcx16 : Flag<["-"], "mcx16">, Group<m_x86_Features_Group>; def mips16 : Flag<["-"], "mips16">, Group<m_Group>; def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_Group>; def mmicromips : Flag<["-"], "mmicromips">, Group<m_Group>; def mno_micromips : Flag<["-"], "mno-micromips">, Group<m_Group>; def mxgot : Flag<["-"], "mxgot">, Group<m_Group>; def mno_xgot : Flag<["-"], "mno-xgot">, Group<m_Group>; +def mldc1_sdc1 : Flag<["-"], "mldc1-sdc1">, Group<m_Group>; +def mno_ldc1_sdc1 : Flag<["-"], "mno-ldc1-sdc1">, Group<m_Group>; +def mcheck_zero_division : Flag<["-"], "mcheck-zero-division">, Group<m_Group>; +def mno_check_zero_division : Flag<["-"], "mno-check-zero-division">, + Group<m_Group>; def mdsp : Flag<["-"], "mdsp">, Group<m_Group>; def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_Group>; def mdspr2 : Flag<["-"], "mdspr2">, Group<m_Group>; def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_Group>; def msingle_float : Flag<["-"], "msingle-float">, Group<m_Group>; def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_Group>; -def mips32 : Flag<["-"], "mips32">, Group<mips_CPUs_Group>, +def mmsa : Flag<["-"], "mmsa">, Group<m_Group>, + HelpText<"Enable MSA ASE (MIPS only)">; +def mno_msa : Flag<["-"], "mno-msa">, Group<m_Group>, + HelpText<"Disable MSA ASE (MIPS only)">; +def mfp64 : Flag<["-"], "mfp64">, Group<m_Group>, + HelpText<"Use 64-bit floating point registers (MIPS only)">; +def mfp32 : Flag<["-"], "mfp32">, Group<m_Group>, + HelpText<"Use 32-bit floating point registers (MIPS only)">; +def mnan_EQ : Joined<["-"], "mnan=">, Group<m_Group>; +def mips32 : Flag<["-"], "mips32">, + Alias<march_EQ>, AliasArgs<["mips32"]>, HelpText<"Equivalent to -march=mips32">, Flags<[HelpHidden]>; -def mips32r2 : Flag<["-"], "mips32r2">, Group<mips_CPUs_Group>, +def mips32r2 : Flag<["-"], "mips32r2">, + Alias<march_EQ>, AliasArgs<["mips32r2"]>, HelpText<"Equivalent to -march=mips32r2">, Flags<[HelpHidden]>; -def mips64 : Flag<["-"], "mips64">, Group<mips_CPUs_Group>, +def mips64 : Flag<["-"], "mips64">, + Alias<march_EQ>, AliasArgs<["mips64"]>, HelpText<"Equivalent to -march=mips64">, Flags<[HelpHidden]>; -def mips64r2 : Flag<["-"], "mips64r2">, Group<mips_CPUs_Group>, +def mips64r2 : Flag<["-"], "mips64r2">, + Alias<march_EQ>, AliasArgs<["mips64r2"]>, HelpText<"Equivalent to -march=mips64r2">, Flags<[HelpHidden]>; def module_file_info : Flag<["-"], "module-file-info">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>; def mthumb : Flag<["-"], "mthumb">, Group<m_Group>; @@ -989,8 +1157,6 @@ def multi__module : Flag<["-"], "multi_module">; def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">; def multiply__defined : Separate<["-"], "multiply_defined">; def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>; -def m_Separate : Separate<["-"], "m">, Group<m_Group>; -def m_Joined : Joined<["-"], "m">, Group<m_Group>; def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden]>, HelpText<"Use relative instead of canonical paths">; def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>; @@ -1004,6 +1170,7 @@ def nodefaultlibs : Flag<["-"], "nodefaultlibs">; def nofixprebinding : Flag<["-"], "nofixprebinding">; def nolibc : Flag<["-"], "nolibc">; def nomultidefs : Flag<["-"], "nomultidefs">; +def nopie : Flag<["-"], "nopie">; def noprebind : Flag<["-"], "noprebind">; def noseglinkedit : Flag<["-"], "noseglinkedit">; def nostartfiles : Flag<["-"], "nostartfiles">; @@ -1084,16 +1251,16 @@ def static_libgcc : Flag<["-"], "static-libgcc">; def static_libstdcxx : Flag<["-"], "static-libstdc++">; def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>; def std_default_EQ : Joined<["-"], "std-default=">; -def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>, Group<L_Group>, - HelpText<"Language standard to compile for">; +def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>, + Group<CompileOnly_Group>, HelpText<"Language standard to compile for">; def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>, HelpText<"C++ standard library to use">; def sub__library : JoinedOrSeparate<["-"], "sub_library">; def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">; def s : Flag<["-"], "s">; -def target : Separate<["-"], "target">, Flags<[DriverOption]>, +def target : Joined<["--"], "target=">, Flags<[DriverOption]>, HelpText<"Generate code for the given target">; -def gcc_toolchain : Separate<["-"], "gcc-toolchain">, Flags<[DriverOption]>, +def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[DriverOption]>, HelpText<"Use the gcc toolchain at the given directory">; def time : Flag<["-"], "time">, HelpText<"Time individual commands">; @@ -1111,7 +1278,6 @@ def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>, HelpText<"undef all system defines">; def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">; def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>; -def use_gold_plugin : Flag<["-"], "use-gold-plugin">; def v : Flag<["-"], "v">, Flags<[CC1Option]>, HelpText<"Show commands to run and use verbose output">; def verify : Flag<["-"], "verify">, Flags<[DriverOption,CC1Option]>, @@ -1136,6 +1302,7 @@ def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option // Double dash options, which are usually an alias for one of the previous // options. +def _mhwdiv_EQ : Separate<["--"], "mhwdiv">, Alias<mhwdiv_EQ>; def _CLASSPATH_EQ : Joined<["--"], "CLASSPATH=">, Alias<fclasspath_EQ>; def _CLASSPATH : Separate<["--"], "CLASSPATH">, Alias<fclasspath_EQ>; def _all_warnings : Flag<["--"], "all-warnings">, Alias<Wall>; @@ -1160,6 +1327,8 @@ def _debug : Flag<["--"], "debug">, Alias<g_Flag>; def _define_macro_EQ : Joined<["--"], "define-macro=">, Alias<D>; def _define_macro : Separate<["--"], "define-macro">, Alias<D>; def _dependencies : Flag<["--"], "dependencies">, Alias<M>; +def _dyld_prefix_EQ : Joined<["--"], "dyld-prefix=">; +def _dyld_prefix : Separate<["--"], "dyld-prefix">, Alias<_dyld_prefix_EQ>; def _encoding_EQ : Joined<["--"], "encoding=">, Alias<fencoding_EQ>; def _encoding : Separate<["--"], "encoding">, Alias<fencoding_EQ>; def _entry : Flag<["--"], "entry">, Alias<e>; @@ -1190,10 +1359,6 @@ def _language_EQ : Joined<["--"], "language=">, Alias<x>; def _language : Separate<["--"], "language">, Alias<x>; def _library_directory_EQ : Joined<["--"], "library-directory=">, Alias<L>; def _library_directory : Separate<["--"], "library-directory">, Alias<L>; -def _machine__EQ : Joined<["--"], "machine-=">, Alias<m_Joined>; -def _machine_ : Joined<["--"], "machine-">, Alias<m_Joined>; -def _machine_EQ : Joined<["--"], "machine=">, Alias<m_Joined>; -def _machine : Separate<["--"], "machine">, Alias<m_Joined>; def _no_line_commands : Flag<["--"], "no-line-commands">, Alias<P>; def _no_standard_includes : Flag<["--"], "no-standard-includes">, Alias<nostdinc>; def _no_standard_libraries : Flag<["--"], "no-standard-libraries">, Alias<nostdlib>; @@ -1241,6 +1406,22 @@ def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>; def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>; def _ : Joined<["--"], "">, Flags<[Unsupported]>; def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">, Group<m_hexagon_Features_Group>; +def mv1 : Flag<["-"], "mv1">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, + AliasArgs<["v1"]>; +def mv2 : Flag<["-"], "mv2">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, + AliasArgs<["v2"]>; +def mv3 : Flag<["-"], "mv3">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, + AliasArgs<["v3"]>; +def mv4 : Flag<["-"], "mv4">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, + AliasArgs<["v4"]>; +def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<march_EQ>, + AliasArgs<["v5"]>; + +// These are legacy user-facing driver-level option spellings. They are always +// aliases for options that are spelled using the more common Unix / GNU flag +// style of double-dash and equals-joined flags. +def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>; +def target_legacy_spelling : Separate<["-"], "target">, Alias<target>; // Special internal option to handle -Xlinker --no-demangle. def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">, @@ -1256,4 +1437,140 @@ def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">, def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">, Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>; +// Ignored options +// FIXME: multiclasess produce suffixes, not prefixes. This is fine for now +// since it is only used in ignored options. +multiclass BooleanFFlag<string name> { + def _f : Flag<["-"], "f"#name>; + def _fno : Flag<["-"], "fno-"#name>; +} + +def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_f_Group>; + +defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_f_Group>; +def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_f_Group>; +def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<clang_ignored_f_Group>; + +defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_f_Group>; +def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_f_Group>; + +// FIXME: This option should be supported and wired up to our diognostics, but +// ignore it for now to avoid breaking builds that use it. +def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>; + +defm eliminate_unused_debug_types : BooleanFFlag<"eliminate-unused-debug-types">, Group<clang_ignored_f_Group>; +defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_f_Group>; +defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>; +defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_f_Group>; +defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>; +defm ident : BooleanFFlag<"ident">, Group<clang_ignored_f_Group>; +defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>; +defm inline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_f_Group>; +defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_f_Group>; +defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>; +defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>; +defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_f_Group>; +defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>; +defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>; +defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_f_Group>; +defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>; +defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>; +defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_f_Group>; +defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>; +defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>; +defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_f_Group>; +defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_f_Group>; +defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>; +defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_f_Group>; +defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>; +defm strength_reduce : + BooleanFFlag<"strength-reduce">, Group<clang_ignored_f_Group>; +defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>; +defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_f_Group>; +defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>; +defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>; +defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_f_Group>; +defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_f_Group>; + + +// gfortran options that we recognize in the driver and pass along when +// invoking GCC to compile Fortran code. +def gfortran_Group : OptionGroup<"gfortran Group">; + +// Generic gfortran options. +def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>; +def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>; +def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>; +def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>; +def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>; + +// "f" options with values for gfortran. +def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>; +def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>; +def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>; +def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>; +def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>; +def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>; +def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>; +def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>; +def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>; +def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>; +def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>; +def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>; +def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>; +def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>; +def fmax_subrecord_length_EQ : Joined<["-"], "fmax-subrecord-length=">, Group<gfortran_Group>; +def frecord_marker_EQ : Joined<["-"], "frecord-marker=">, Group<gfortran_Group>; + +// "f" flags for gfortran. +defm aggressive_function_elimination : BooleanFFlag<"aggressive-function-elimination">, Group<gfortran_Group>; +defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>; +defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>; +defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>; +defm backslash : BooleanFFlag<"backslash">, Group<gfortran_Group>; +defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>; +defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>; +defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>; +defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>; +defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>; +defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>; +defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>; +defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>; +defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>; +defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>; +defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>; +defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>; +defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>; +defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>; +defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>; +defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>; +defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>; +defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>; +defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>; +defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>; +defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>; +defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>; +defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>; +defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>; +defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>; +defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>; +defm range_check : BooleanFFlag<"range-check">, Group<gfortran_Group>; +defm real_4_real_10 : BooleanFFlag<"real-4-real-10">, Group<gfortran_Group>; +defm real_4_real_16 : BooleanFFlag<"real-4-real-16">, Group<gfortran_Group>; +defm real_4_real_8 : BooleanFFlag<"real-4-real-8">, Group<gfortran_Group>; +defm real_8_real_10 : BooleanFFlag<"real-8-real-10">, Group<gfortran_Group>; +defm real_8_real_16 : BooleanFFlag<"real-8-real-16">, Group<gfortran_Group>; +defm real_8_real_4 : BooleanFFlag<"real-8-real-4">, Group<gfortran_Group>; +defm realloc_lhs : BooleanFFlag<"realloc-lhs">, Group<gfortran_Group>; +defm recursive : BooleanFFlag<"recursive">, Group<gfortran_Group>; +defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>; +defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>; +defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>; +defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>; +defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>; +defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>; + + include "CC1Options.td" + +include "CLCompatOptions.td" diff --git a/include/clang/Driver/SanitizerArgs.h b/include/clang/Driver/SanitizerArgs.h new file mode 100644 index 0000000..35b8f89 --- /dev/null +++ b/include/clang/Driver/SanitizerArgs.h @@ -0,0 +1,147 @@ +//===--- SanitizerArgs.h - Arguments for sanitizer tools -------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#ifndef CLANG_LIB_DRIVER_SANITIZERARGS_H_ +#define CLANG_LIB_DRIVER_SANITIZERARGS_H_ + +#include <string> + +#include "llvm/Option/Arg.h" +#include "llvm/Option/ArgList.h" + +namespace clang { +namespace driver { + +class Driver; +class ToolChain; + +class SanitizerArgs { + /// Assign ordinals to sanitizer flags. We'll use the ordinal values as + /// bit positions within \c Kind. + enum SanitizeOrdinal { +#define SANITIZER(NAME, ID) SO_##ID, +#define SANITIZER_GROUP(NAME, ID, ALIAS) SO_##ID##Group, +#include "clang/Basic/Sanitizers.def" + SO_Count + }; + + /// Bugs to catch at runtime. + enum SanitizeKind { +#define SANITIZER(NAME, ID) ID = 1 << SO_##ID, +#define SANITIZER_GROUP(NAME, ID, ALIAS) \ + ID = ALIAS, ID##Group = 1 << SO_##ID##Group, +#include "clang/Basic/Sanitizers.def" + NeedsAsanRt = Address, + NeedsTsanRt = Thread, + NeedsMsanRt = Memory, + NeedsDfsanRt = DataFlow, + NeedsLeakDetection = Leak, + NeedsUbsanRt = Undefined | Integer, + NotAllowedWithTrap = Vptr, + HasZeroBaseShadow = Thread | Memory | DataFlow + }; + unsigned Kind; + + std::string BlacklistFile; + bool MsanTrackOrigins; + bool AsanZeroBaseShadow; + bool UbsanTrapOnError; + + public: + SanitizerArgs(); + /// Parses the sanitizer arguments from an argument list. + SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args); + + bool needsAsanRt() const { return Kind & NeedsAsanRt; } + bool needsTsanRt() const { return Kind & NeedsTsanRt; } + bool needsMsanRt() const { return Kind & NeedsMsanRt; } + bool needsLeakDetection() const { return Kind & NeedsLeakDetection; } + bool needsLsanRt() const { + return needsLeakDetection() && !needsAsanRt(); + } + bool needsUbsanRt() const { + return !UbsanTrapOnError && (Kind & NeedsUbsanRt); + } + bool needsDfsanRt() const { return Kind & NeedsDfsanRt; } + + bool sanitizesVptr() const { return Kind & Vptr; } + bool notAllowedWithTrap() const { return Kind & NotAllowedWithTrap; } + bool hasZeroBaseShadow() const { + return (Kind & HasZeroBaseShadow) || AsanZeroBaseShadow; + } + void addArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const; + + private: + void clear(); + + /// Parse a single value from a -fsanitize= or -fno-sanitize= value list. + /// Returns OR of members of the \c SanitizeKind enumeration, or \c 0 + /// if \p Value is not known. + static unsigned parse(const char *Value); + + /// Parse a -fsanitize= or -fno-sanitize= argument's values, diagnosing any + /// invalid components. + static unsigned parse(const Driver &D, const llvm::opt::Arg *A, + bool DiagnoseErrors); + + /// Parse a single flag of the form -f[no]sanitize=, or + /// -f*-sanitizer. Sets the masks defining required change of Kind value. + /// Returns true if the flag was parsed successfully. + static bool parse(const Driver &D, const llvm::opt::ArgList &Args, + const llvm::opt::Arg *A, unsigned &Add, unsigned &Remove, + bool DiagnoseErrors); + + /// Produce an argument string from ArgList \p Args, which shows how it + /// provides a sanitizer kind in \p Mask. For example, the argument list + /// "-fsanitize=thread,vptr -faddress-sanitizer" with mask \c NeedsUbsanRt + /// would produce "-fsanitize=vptr". + static std::string lastArgumentForKind(const Driver &D, + const llvm::opt::ArgList &Args, + unsigned Kind); + + /// Produce an argument string from argument \p A, which shows how it provides + /// a value in \p Mask. For instance, the argument + /// "-fsanitize=address,alignment" with mask \c NeedsUbsanRt would produce + /// "-fsanitize=alignment". + static std::string describeSanitizeArg(const llvm::opt::ArgList &Args, + const llvm::opt::Arg *A, + unsigned Mask); + + static bool getDefaultBlacklistForKind(const Driver &D, unsigned Kind, + std::string &BLPath); + + /// Return the smallest superset of sanitizer set \p Kinds such that each + /// member of each group whose flag is set in \p Kinds has its flag set in the + /// result. + static unsigned expandGroups(unsigned Kinds); + + /// Return the subset of \p Kinds supported by toolchain \p TC. If + /// \p DiagnoseErrors is true, produce an error diagnostic for each sanitizer + /// removed from \p Kinds. + static unsigned filterUnsupportedKinds(const ToolChain &TC, unsigned Kinds, + const llvm::opt::ArgList &Args, + const llvm::opt::Arg *A, + bool DiagnoseErrors, + unsigned &DiagnosedKinds); + + /// The flags in \p Mask are unsupported by \p TC. If present in \p Kinds, + /// remove them and produce an error diagnostic referring to \p A if + /// \p DiagnoseErrors is true. + static void filterUnsupportedMask(const ToolChain &TC, unsigned &Kinds, + unsigned Mask, + const llvm::opt::ArgList &Args, + const llvm::opt::Arg *A, + bool DiagnoseErrors, + unsigned &DiagnosedKinds); +}; + +} // namespace driver +} // namespace clang + +#endif // CLANG_LIB_DRIVER_SANITIZERARGS_H_ diff --git a/include/clang/Driver/Tool.h b/include/clang/Driver/Tool.h index 4c05d0a..015dcf5 100644 --- a/include/clang/Driver/Tool.h +++ b/include/clang/Driver/Tool.h @@ -12,9 +12,15 @@ #include "clang/Basic/LLVM.h" +namespace llvm { +namespace opt { + class ArgList; +} +} + namespace clang { namespace driver { - class ArgList; + class Compilation; class InputInfo; class Job; @@ -57,7 +63,8 @@ public: virtual bool hasGoodDiagnostics() const { return false; } /// ConstructJob - Construct jobs to perform the action \p JA, - /// writing to \p Output and with \p Inputs. + /// writing to \p Output and with \p Inputs, and add the jobs to + /// \p C. /// /// \param TCArgs - The argument list for this toolchain, with any /// tool chain specific translations applied. @@ -66,7 +73,7 @@ public: virtual void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, - const ArgList &TCArgs, + const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const = 0; }; diff --git a/include/clang/Driver/ToolChain.h b/include/clang/Driver/ToolChain.h index aae3d79..84e0b55 100644 --- a/include/clang/Driver/ToolChain.h +++ b/include/clang/Driver/ToolChain.h @@ -19,16 +19,22 @@ #include "llvm/Support/Path.h" #include <string> +namespace llvm { +namespace opt { + class ArgList; + class DerivedArgList; + class InputArgList; +} +} + namespace clang { class ObjCRuntime; namespace driver { - class ArgList; class Compilation; - class DerivedArgList; class Driver; - class InputArgList; class JobAction; + class SanitizerArgs; class Tool; /// ToolChain - Access to tools for a single platform. @@ -49,7 +55,7 @@ public: private: const Driver &D; const llvm::Triple Triple; - const ArgList &Args; + const llvm::opt::ArgList &Args; /// The list of toolchain specific path prefixes to search for /// files. @@ -67,8 +73,11 @@ private: Tool *getLink() const; Tool *getClangAs() const; + mutable OwningPtr<SanitizerArgs> SanitizerArguments; + protected: - ToolChain(const Driver &D, const llvm::Triple &T, const ArgList &Args); + ToolChain(const Driver &D, const llvm::Triple &T, + const llvm::opt::ArgList &Args); virtual Tool *buildAssembler() const; virtual Tool *buildLinker() const; @@ -76,17 +85,18 @@ protected: /// \name Utilities for implementing subclasses. ///@{ - static void addSystemInclude(const ArgList &DriverArgs, - ArgStringList &CC1Args, + static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args, const Twine &Path); - static void addExternCSystemInclude(const ArgList &DriverArgs, - ArgStringList &CC1Args, + static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args, + const Twine &Path); + static void + addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args, const Twine &Path); - static void addExternCSystemIncludeIfExists(const ArgList &DriverArgs, - ArgStringList &CC1Args, - const Twine &Path); - static void addSystemIncludes(const ArgList &DriverArgs, - ArgStringList &CC1Args, + static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args, ArrayRef<StringRef> Paths); ///@} @@ -117,6 +127,8 @@ public: path_list &getProgramPaths() { return ProgramPaths; } const path_list &getProgramPaths() const { return ProgramPaths; } + const SanitizerArgs& getSanitizerArgs() const; + // Tool access. /// TranslateArgs - Create a new derived argument list for any argument @@ -124,8 +136,9 @@ public: /// specific translations are needed. /// /// \param BoundArch - The bound architecture name, or 0. - virtual DerivedArgList *TranslateArgs(const DerivedArgList &Args, - const char *BoundArch) const { + virtual llvm::opt::DerivedArgList * + TranslateArgs(const llvm::opt::DerivedArgList &Args, + const char *BoundArch) const { return 0; } @@ -137,6 +150,13 @@ public: std::string GetFilePath(const char *Name) const; std::string GetProgramPath(const char *Name) const; + /// \brief Dispatch to the specific toolchain for verbose printing. + /// + /// This is used when handling the verbose option to print detailed, + /// toolchain-specific information useful for understanding the behavior of + /// the driver on a specific platform. + virtual void printVerboseInfo(raw_ostream &OS) const {}; + // Platform defaults information /// HasNativeLTOLinker - Check whether the linker and related tools have @@ -157,17 +177,9 @@ public: /// \brief Check if the toolchain should use the integrated assembler. bool useIntegratedAs() const; - /// IsStrictAliasingDefault - Does this tool chain use -fstrict-aliasing by - /// default. - virtual bool IsStrictAliasingDefault() const { return true; } - /// IsMathErrnoDefault - Does this tool chain use -fmath-errno by default. virtual bool IsMathErrnoDefault() const { return true; } - /// IsObjCDefaultSynthPropertiesDefault - Does this tool chain enable - /// -fobjc-default-synthesize-properties by default. - virtual bool IsObjCDefaultSynthPropertiesDefault() const { return true; } - /// IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable /// -fencode-extended-block-signature by default. virtual bool IsEncodeExtendedBlockSignatureDefault() const { return false; } @@ -225,16 +237,18 @@ public: /// ComputeLLVMTriple - Return the LLVM target triple to use, after taking /// command line arguments into account. - virtual std::string ComputeLLVMTriple(const ArgList &Args, - types::ID InputType = types::TY_INVALID) const; + virtual std::string + ComputeLLVMTriple(const llvm::opt::ArgList &Args, + types::ID InputType = types::TY_INVALID) const; /// ComputeEffectiveClangTriple - Return the Clang triple to use for this /// target, which may take into account the command line arguments. For /// example, on Darwin the -mmacosx-version-min= command line argument (which /// sets the deployment target) determines the version in the triple passed to /// Clang. - virtual std::string ComputeEffectiveClangTriple(const ArgList &Args, - types::ID InputType = types::TY_INVALID) const; + virtual std::string ComputeEffectiveClangTriple( + const llvm::opt::ArgList &Args, + types::ID InputType = types::TY_INVALID) const; /// getDefaultObjCRuntime - Return the default Objective-C runtime /// for this platform. @@ -253,42 +267,46 @@ public: /// /// This routine is responsible for adding the necessary cc1 arguments to /// include headers from standard system header directories. - virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const; + virtual void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const; /// \brief Add options that need to be passed to cc1 for this target. - virtual void addClangTargetOptions(const ArgList &DriverArgs, - ArgStringList &CC1Args) const; + virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const; // GetRuntimeLibType - Determine the runtime library type to use with the // given compilation arguments. - virtual RuntimeLibType GetRuntimeLibType(const ArgList &Args) const; + virtual RuntimeLibType + GetRuntimeLibType(const llvm::opt::ArgList &Args) const; // GetCXXStdlibType - Determine the C++ standard library type to use with the // given compilation arguments. - virtual CXXStdlibType GetCXXStdlibType(const ArgList &Args) const; + virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const; /// AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set /// the include paths to use for the given C++ standard library type. - virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const; + virtual void + AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const; /// AddCXXStdlibLibArgs - Add the system specific linker arguments to use /// for the given C++ standard library type. - virtual void AddCXXStdlibLibArgs(const ArgList &Args, - ArgStringList &CmdArgs) const; + virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const; /// AddCCKextLibArgs - Add the system specific linker arguments to use /// for kernel extensions (Darwin-specific). - virtual void AddCCKextLibArgs(const ArgList &Args, - ArgStringList &CmdArgs) const; + virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const; /// AddFastMathRuntimeIfAvailable - If a runtime library exists that sets /// global flags for unsafe floating point math, add it and return true. /// /// This checks for presence of the -ffast-math or -funsafe-math flags. - virtual bool AddFastMathRuntimeIfAvailable(const ArgList &Args, - ArgStringList &CmdArgs) const; + virtual bool + AddFastMathRuntimeIfAvailable(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const; }; } // end namespace driver diff --git a/include/clang/Driver/Types.def b/include/clang/Driver/Types.def index 42f0709..d4f52d3 100644 --- a/include/clang/Driver/Types.def +++ b/include/clang/Driver/Types.def @@ -66,7 +66,7 @@ TYPE("objective-c++-header", ObjCXXHeader, PP_ObjCXXHeader, 0, "pu") // Other languages. TYPE("ada", Ada, INVALID, 0, "u") TYPE("assembler", PP_Asm, INVALID, "s", "au") -TYPE("assembler-with-cpp", Asm, PP_Asm, 0, "au") +TYPE("assembler-with-cpp", Asm, PP_Asm, "S", "au") TYPE("f95", PP_Fortran, INVALID, 0, "u") TYPE("f95-cpp-input", Fortran, PP_Fortran, 0, "u") TYPE("java", Java, INVALID, 0, "u") diff --git a/include/clang/Driver/Types.h b/include/clang/Driver/Types.h index 18cd2d5..cca576a 100644 --- a/include/clang/Driver/Types.h +++ b/include/clang/Driver/Types.h @@ -34,7 +34,7 @@ namespace types { /// getTypeTempSuffix - Return the suffix to use when creating a /// temp file of this type, or null if unspecified. - const char *getTypeTempSuffix(ID Id); + const char *getTypeTempSuffix(ID Id, bool CLMode = false); /// onlyAssembleType - Should this type only be assembled. bool onlyAssembleType(ID Id); @@ -78,7 +78,7 @@ namespace types { /// done for type 'Id'. void getCompilationPhases( ID Id, - llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &Phases); + llvm::SmallVectorImpl<phases::ID> &Phases); /// lookupCXXTypeForCType - Lookup CXX input type that corresponds to given /// C type (used for clang++ emulation of g++ behaviour) diff --git a/include/clang/Driver/Util.h b/include/clang/Driver/Util.h index 06b82b9..b24b990 100644 --- a/include/clang/Driver/Util.h +++ b/include/clang/Driver/Util.h @@ -14,13 +14,12 @@ #include "llvm/ADT/DenseMap.h" namespace clang { +class DiagnosticsEngine; + namespace driver { class Action; class JobAction; - /// ArgStringList - Type used for constructing argv lists for subprocesses. - typedef SmallVector<const char*, 16> ArgStringList; - /// ArgStringMap - Type used to map a JobAction to its result file. typedef llvm::DenseMap<const JobAction*, const char*> ArgStringMap; |
