iterator end() { return Inputs.end(); }

const_iterator begin() const { return Inputs.begin(); }

const_iterator end() const { return Inputs.end(); }

};

class InputAction : public Action {

static bool classof(const Action *A) {

return A->getKind() == InputClass;

}

};

class BindArchAction : public Action {

static bool classof(const Action *A) {

return A->getKind() == BindArchClass;

}

};

class JobAction : public Action {

return (A->getKind() >= JobClassFirst &&

A->getKind() <= JobClassLast);

}

};

class PreprocessJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == PreprocessJobClass;

}

};

class PrecompileJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == PrecompileJobClass;

}

};

class AnalyzeJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == AnalyzeJobClass;

}

};

class MigrateJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == MigrateJobClass;

}

};

class CompileJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == CompileJobClass;

}

};

class AssembleJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == AssembleJobClass;

}

};

class LinkJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == LinkJobClass;

}

};

class LipoJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == LipoJobClass;

}

};

class DsymutilJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == DsymutilJobClass;

}

};

class VerifyJobAction : public JobAction {

static bool classof(const Action *A) {

return A->getKind() == VerifyJobClass;

}

};

} // end namespace driver

#ifndef CLANG_DRIVER_ARG_H_

#define CLANG_DRIVER_ARG_H_

#include "Util.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

namespace clang {

namespace driver {

class ArgList;

/// \brief A concrete instance of a particular driver option.

///

/// ArgList to provide efficient iteration over all instances of a

/// particular option.

class Arg {

private:

/// \brief The option this argument is an instance of.

/// \brief The argument this argument was derived from (during tool chain

/// argument translation), if any.

const Arg *BaseArg;

/// \brief The index at which this argument appears in the containing

/// ArgList.

unsigned Index;

SmallVector<const char *, 2> Values;

public:

const char *Value0, const Arg *BaseArg = 0);

const char *Value0, const char *Value1, const Arg *BaseArg = 0);

~Arg();

unsigned getIndex() const { return Index; }

/// \brief Return the base argument which generated this arg.

void claim() const { getBaseArg().Claimed = true; }

unsigned getNumValues() const { return Values.size(); }

return Values[N];

}

/// 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

#define CLANG_DRIVER_ARGLIST_H_

#include "clang/Basic/LLVM.h"

#include "clang/Driver/OptSpecifier.h"

#include "clang/Driver/Util.h"

#include "llvm/ADT/SmallVector.h"

/// and to iterate over groups of arguments.

class ArgList {

private:

public:

typedef SmallVector<Arg*, 16> arglist_type;

/// @name Arg Access

/// @{

void append(Arg *A);

arglist_type &getArgs() { return Args; }

/// @name Arg Removal

/// @{

void eraseArg(OptSpecifier Id);

/// @}

/// @name Arg Access

/// @{

///

bool hasArgNoClaim(OptSpecifier Id) const {

return getLastArgNoClaim(Id) != 0;

}

return getLastArg(Id0, Id1, Id2) != 0;

}

///

Arg *getLastArgNoClaim(OptSpecifier Id) const;

Arg *getLastArg(OptSpecifier Id) const;

Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1) const;

OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5,

OptSpecifier Id6, OptSpecifier Id7) const;

virtual const char *getArgString(unsigned Index) const = 0;

/// getNumInputArgStrings - Return the number of original argument strings,

/// @name Translation Utilities

/// @{

bool hasFlag(OptSpecifier Pos, OptSpecifier Neg, bool Default=true) const;

void AddLastArg(ArgStringList &Output, OptSpecifier Id0) const;

/// AddAllArgs - Render all arguments matching the given ids.

}

const char *MakeArgString(const Twine &Str) const;

const char *GetOrMakeJoinedArgString(unsigned Index, StringRef LHS,

StringRef RHS) const;

mutable arglist_type SynthesizedArgs;

public:

DerivedArgList(const InputArgList &BaseArgs);

~DerivedArgList();

virtual const char *MakeArgString(StringRef Str) const;

/// append it to the argument list.

append(MakeFlagArg(BaseArg, Opt));

}

/// AddPositionalArg - Construct a new Positional arg for the given option

/// list.

StringRef Value) {

append(MakePositionalArg(BaseArg, Opt, Value));

}

/// AddSeparateArg - Construct a new Positional arg for the given option

/// list.

StringRef Value) {

append(MakeSeparateArg(BaseArg, Opt, Value));

}

StringRef Value) {

append(MakeJoinedArg(BaseArg, Opt, Value));

}

/// MakePositionalArg - Construct a new Positional arg for the

StringRef Value) const;

/// MakeSeparateArg - Construct a new Positional arg for the

StringRef Value) const;

/// MakeJoinedArg - Construct a new Positional arg for the

StringRef Value) const;

/// @}

namespace cc1asoptions {

enum ID {

OPT_INVALID = 0, // This is not an option ID.

HELPTEXT, METAVAR) OPT_##ID,

#include "clang/Driver/CC1AsOptions.inc"

LastOption

#undef OPTION

};

}

// Target Options

//===----------------------------------------------------------------------===//

HelpText<"Specify target triple (e.g. x86_64-pc-linux-gnu)">;

HelpText<"Target a specific cpu type">;

HelpText<"Target specific attributes">;

//===----------------------------------------------------------------------===//

// Language Options

//===----------------------------------------------------------------------===//

HelpText<"Add directory to include search path">;

HelpText<"Don't automatically start assembly file with a text section">;

HelpText<"Save temporary labels in the symbol table. "

"Note this may change .s semantics, it should almost never be used "

"on compiler generated code!">;

// Frontend Options

//===----------------------------------------------------------------------===//

HelpText<"Specify the output file type ('asm', 'null', or 'obj')">;

HelpText<"Print this help text">;

HelpText<"Print the assembler version">;

// Generic forwarding to LLVM options. This should only be used for debugging

// and experimental features.

HelpText<"Additional arguments to forward to LLVM's option processing">;

//===----------------------------------------------------------------------===//

// Transliterate Options

//===----------------------------------------------------------------------===//

HelpText<"Select the asm variant index to use for output">;

HelpText<"Show instruction encoding information in transliterate mode">;

HelpText<"Show internal instruction representation in transliterate mode">;

//===----------------------------------------------------------------------===//

// Assemble Options

//===----------------------------------------------------------------------===//

HelpText<"Relax all fixups (for performance testing)">;

HelpText<"Mark the file as not needing an executable stack">;

HelpText<"Consider warnings as errors">;

HelpText<"The string to embed in the Dwarf debug flags record.">;

//

//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//

// Target Options

//===----------------------------------------------------------------------===//

HelpText<"Target a particular C++ ABI type">;

HelpText<"Target a particular ABI type">;

HelpText<"Target a specific cpu type">;

HelpText<"Target specific attributes">;

HelpText<"Target linker version">;

HelpText<"Specify target triple (e.g. i686-apple-darwin9)">;

//===----------------------------------------------------------------------===//

// Analyzer Options

//===----------------------------------------------------------------------===//

HelpText<"Generate unoptimized CFGs for all analyses">;

HelpText<"Add C++ implicit destructors to CFGs for all analyses">;

HelpText<"Source Code Analysis - Abstract Memory Store Models">;

HelpText<"Source Code Analysis - Symbolic Constraint Engines">;

Alias<analyzer_constraints>;

HelpText<"Source Code Analysis - Output Options">;

Alias<analyzer_output>;

HelpText<"Source Code Analysis - Dead Symbol Removal Frequency">;

HelpText<"Force the static analyzer to analyze functions defined in header files">;

HelpText<"Analyze the definitions of blocks in addition to functions">;

HelpText<"Emit verbose output about the analyzer's progress">;

HelpText<"Run analysis on specific function">;

HelpText<"Eagerly assume the truth/falseness of some symbolic constraints">;

HelpText<"Only show error-related paths in the analysis graph">;

HelpText<"Display exploded graph using GraphViz">;

HelpText<"Display exploded graph using Ubigraph">;

HelpText<"Bound on stack depth while inlining (4 by default)">;

Alias<analyzer_inline_max_stack_depth>;

HelpText<"Bound on the number of basic blocks in an inlined function (200 by default)">;

Alias<analyzer_inline_max_function_size>;

HelpText<"Specify the inter-procedural analysis mode">;

HelpText<"Specify the function selection heuristic used during inlining">;

HelpText<"Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)">;

HelpText<"The maximum number of nodes the analyzer can generate (150000 default, 0 = no limit)">;

HelpText<"The maximum number of times the analyzer will go through a loop">;

HelpText<"Print internal analyzer statistics.">;

HelpText<"Choose analyzer checkers to enable">;

Alias<analyzer_checker>;

HelpText<"Choose analyzer checkers to disable">;

Alias<analyzer_disable_checker>;

HelpText<"Display the list of analyzer checkers that are available">;

//===----------------------------------------------------------------------===//

// Migrator Options

//===----------------------------------------------------------------------===//

HelpText<"Do not error on use of NSAllocateCollectable/NSReallocateCollectable">;

HelpText<"Do not remove finalize method in gc mode">;

//===----------------------------------------------------------------------===//

// CodeGen Options

//===----------------------------------------------------------------------===//

HelpText<"Don't run LLVM optimization passes">;

HelpText<"Don't run the LLVM IR verifier pass">;

HelpText<"Do not emit code that uses the red zone.">;

HelpText<"The compilation directory to embed in the debug info.">;

HelpText<"The string to embed in the Dwarf debug flags record.">;

HelpText<"Emit an error if a C++ static local initializer would need a guard variable">;

HelpText<"Don't generate implicit floating point instructions">;

HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">;

HelpText<"Emit a gcov coverage notes file when compiling.">;

HelpText<"Instrument the program to emit gcov coverage data when run.">;

HelpText<"Emit coverage data to this filename. The extension will be replaced.">;

HelpText<"Use register sized accesses to bit-fields, when possible.">;

HelpText<"Turn off Type Based Alias Analysis">;

HelpText<"Generate verbose assembly output">;

HelpText<"The code model to use">;

HelpText<"Enable additional debug output">;

HelpText<"Disable frame pointer elimination optimization">;

HelpText<"Disable tail call optimization, keeping the call stack accurate">;

HelpText<"Allow optimization to assume there are no infinities.">;

HelpText<"Allow optimization to assume there are no NaNs.">;

HelpText<"Allow unsafe floating-point math optimizations which may decrease "

"precision">;

HelpText<"The float ABI to use">;

HelpText<"Limit float precision to the given value">;

HelpText<"Mark the file as not needing an executable stack">;

HelpText<"Do not put zero initialized data in the BSS">;

HelpText<"Additional arguments to forward to LLVM backend (during code gen)">;

HelpText<"Limit the number of registers available for integer arguments">;

HelpText<"(integrated-as) Save temporary labels">;

HelpText<"The relocation model to use">;

HelpText<"Generate unwinding tables for all functions">;

HelpText<"Use .init_array instead of .ctors">;

HelpText<"Emit complete constructors and destructors as aliases when possible">;

HelpText<"Link the given bitcode file before performing optimizations.">;

//===----------------------------------------------------------------------===//

// Dependency Output Options

//===----------------------------------------------------------------------===//

HelpText<"Include system headers in dependency output">;

HelpText<"Filename (or -) to write header include output to">;

//===----------------------------------------------------------------------===//

// Diagnostic Options

//===----------------------------------------------------------------------===//

MetaVarName<"<filename>">,

HelpText<"output a dump of some build information to a file">;

HelpText<"Filename (or -) to log diagnostics to">;

MetaVarName<"<filename>">,

HelpText<"File for serializing diagnostics in a binary format">;

HelpText<"Change diagnostic formatting to match IDE and command line tools">;

HelpText<"Print diagnostic category">;

HelpText<"Set the tab stop distance.">;

HelpText<"Set the maximum number of errors to emit before stopping (0 = no limit).">;

HelpText<"Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit).">;

HelpText<"Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit).">;

HelpText<"Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit).">;

HelpText<"Format message diagnostics so that they fit within N columns or fewer, when possible.">;

HelpText<"Silence ObjC rewriting warnings">;

//===----------------------------------------------------------------------===//

// This isn't normally used, it is just here so we can parse a

// CompilerInvocation out of a driver-derived argument vector.

MetaVarName<"<ast file>">,

HelpText<"Merge the given AST file into the translation unit being compiled.">;

MetaVarName<"<file>:<line>:<column>">,

HelpText<"Dump code-completion information at a location">;

MetaVarName<"<from>;<to>">,

HelpText<"Replace the contents of the <from> file with the contents of the <to> file">;

Alias<code_completion_at>;

HelpText<"Include macros in code-completion results">;

HelpText<"Include code patterns in code-completion results">;

HelpText<"Do not include global declarations in code-completion results.">;

HelpText<"Include brief documentation comments in code-completion results.">;

HelpText<"Disable freeing of memory on exit">;

HelpText<"Load the named plugin (dynamic shared object)">;

HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">;

MetaVarName<"<name> <arg>">,

HelpText<"Pass <arg> to plugin <name>">;

HelpText<"Use the named plugin action in addition to the default action">;

HelpText<"The directory which holds the compiler resource files">;

HelpText<"Print the compiler version">;

MetaVarName<"<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"

let Group = Action_Group in {

HelpText<"Just run preprocessor, no output (for timings)">;

HelpText<"Lex file in raw mode and dump raw tokens">;

HelpText<"Run static analysis engine">;

HelpText<"Run preprocessor, dump internal rep of tokens">;

HelpText<"Only execute frontend initialization">;

HelpText<"Apply fix-it advice to the input source">;

HelpText<"Apply fix-it advice creating a file with the given suffix">;

HelpText<"Print the \"preamble\" of a file, which is a candidate for implicit"

" precompiled headers.">;

HelpText<"Output input source as HTML">;

HelpText<"Build ASTs and then pretty-print them">;

HelpText<"Build ASTs and print the list of declaration node qualified names">;

HelpText<"Build ASTs and then debug dump them">;

HelpText<"Build ASTs and then debug dump them in a verbose XML format">;

HelpText<"Build ASTs and view them with GraphViz">;

HelpText<"Print DeclContexts and their Decls">;

HelpText<"Generate pre-compiled module file from a module map">;

HelpText<"Generate pre-tokenized header file">;

HelpText<"Generate pre-compiled header file">;

HelpText<"Build ASTs then convert to LLVM, emit .bc file">;

HelpText<"Build ASTs and convert to LLVM, discarding output">;

HelpText<"Generate machine code, but discard output">;

HelpText<"Emit native object files">;

HelpText<"Rewriter playground">;

HelpText<"Expand macros without full preprocessing">;

HelpText<"Migrate source code">;

}

HelpText<"Directory for temporary files produced during ARC or ObjC migration">;

HelpText<"Check for ARC migration issues that need manual handling">;

HelpText<"Apply modifications to files to conform to ARC">;

HelpText<"Apply modifications and produces temporary files that conform to ARC">;

HelpText<"Whether to build a relocatable precompiled header">;

HelpText<"Print performance metrics and statistics">;

HelpText<"Dump record layout information">;

HelpText<"Dump record layout information in a simple form used for testing">;

HelpText<"Apply fix-it advice even in the presence of unfixable errors">;

HelpText<"Apply fix-it advice only for warnings, not errors">;

HelpText<"Apply fix-it changes and recompile">;

HelpText<"Apply fix-it changes to temporary files">;

HelpText<"Override record layouts with those in the given file">;

//===----------------------------------------------------------------------===//

// Language Options

//===----------------------------------------------------------------------===//

HelpText<"Weakly link in the blocks runtime">;

HelpText<"Use SjLj style exceptions">;

HelpText<"Generate weak vtables and RTTI with hidden visibility">;

HelpText<"Main file name to use for debug info">;

HelpText<"Char is unsigned">;

MetaVarName<"<class name>">,

HelpText<"Specify the class to use for constant Objective-C string objects.">;

HelpText<"Objective-C++ Automatic Reference Counting standard library kind">;

HelpText<"The target Objective-C runtime supports ARC weak operations">;

HelpText<"Objective-C dispatch method to use">;

HelpText<"enable the default synthesis of Objective-C properties">;

HelpText<"Value for __PIC__">;

HelpText<"Value for __PIE__">;

HelpText<"Disable validation of precompiled headers">;

HelpText<"Dump declarations that are deserialized from PCH, for testing">;

HelpText<"Emit error if a specific declaration is deserialized from PCH, for testing">;

Alias<error_on_deserialized_pch_decl>;

HelpText<"Should __STATIC__ be defined">;

HelpText<"Enable stack protectors">;

HelpText<"Default symbol visibility">;

HelpText<"Maximum depth of recursive template instantiation">;

HelpText<"Maximum depth of recursive constexpr function calls">;

HelpText<"Use a const qualified type for string literals in C and ObjC">;

HelpText<"Don't use a const qualified type for string literals in C and ObjC">;

HelpText<"Ignore bit-field types when aligning structures">;

HelpText<"Use a fake address space map; OpenCL testing purposes only">;

HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">;

HelpText<"Enable special debugger support behavior">;

HelpText<"Enable casting unknown expression results to id">;

HelpText<"Enable special debugger support for Objective-C subscripting and literals">;

HelpText<"Defines the __DEPRECATED macro">;

HelpText<"Undefines the __DEPRECATED macro">;

//===----------------------------------------------------------------------===//

// Header Search Options

//===----------------------------------------------------------------------===//

HelpText<"Disable standard system #include directories">;

MetaVarName<"<name>">,

HelpText<"Specify the name of the module to build">;

HelpText<"Disable the module hash">;

HelpText<"Add directory to the C SYSTEM include search path">;

MetaVarName<"<directory>">,

HelpText<"Add directory to the ObjC SYSTEM include search path">;

MetaVarName<"<directory>">,

HelpText<"Add directory to the ObjC++ SYSTEM include search path">;

MetaVarName<"<directory>">,

HelpText<"Add directory to the internal system include search path; these "

"are assumed to not be user-provided and are used to model system "

"and standard headers' paths.">;

MetaVarName<"<directory>">,

HelpText<"Add directory to the internal system include search path with "

"implicit extern \"C\" semantics; these are assumed to not be "

"user-provided and are used to model system and standard headers' "

"paths.">;

MetaVarName<"<prefix>">,

HelpText<"Treat all #include paths starting with <prefix> as including a "

"system header.">;

MetaVarName<"<prefix>">,

HelpText<"Treat all #include paths starting with <prefix> as not including a "

"system header.">;

// Preprocessor Options

//===----------------------------------------------------------------------===//

HelpText<"Include file before parsing">;

HelpText<"Include and chain a header file after turning it into PCH">;

HelpText<"Assume that the precompiled header is a precompiled preamble "

"covering the first N bytes of the main file">;

HelpText<"Use specified token cache file">;

HelpText<"include a detailed record of preprocessing actions">;

//===----------------------------------------------------------------------===//

// OpenCL Options

//===----------------------------------------------------------------------===//

HelpText<"OpenCL only. This option disables all optimizations. The default is optimizations are enabled.">;

HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">;

HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">;

HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable">;

HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__">;

HelpText<"OpenCL only. Enable less precise MAD instructions to be generated.">;

HelpText<"OpenCL language standard to compile for">;

//===----------------------------------------------------------------------===//

// CUDA Options

//===----------------------------------------------------------------------===//

HelpText<"Generate code for CUDA device">;

} // let Flags = [CC1Option]

StringRef getSysRoot() const;

/// getArgsForToolChain - Return the derived argument list for the

///

/// \param BoundArch - The bound architecture name, or 0.

const DerivedArgList &getArgsForToolChain(const ToolChain *TC,

void PrintJob(raw_ostream &OS, const Job &J,

const char *Terminator, bool Quote) const;

/// ExecuteCommand - Execute an actual command.

///

/// \param FailingCommand - For non-zero results, this will be set to the

/// jobs.

unsigned CheckInputsExist : 1;

public:

/// Use lazy precompiled headers for PCH support.

unsigned CCCUsePCH : 1;

private:

/// Certain options suppress the 'no input files' warning.

bool SuppressMissingInputWarning : 1;

InstalledDir = Value;

}

/// @}

/// @name Primary Functionality

/// @{

/// BuildJobs - Bind actions to concrete tools and translate

/// arguments to form the list of jobs to run.

///

void BuildJobs(Compilation &C) const;

/// ExecuteCompilation - Execute the compilation according to the command line

/// PrintVersion - Print the driver version.

void PrintVersion(const Compilation &C, raw_ostream &OS) const;

///

/// directories to search.

//

// FIXME: This should be in CompilationInfo.

std::string GetFilePath(const char *Name, const ToolChain &TC) const;

///

/// directories to search.

//

// FIXME: This should be in CompilationInfo.

/// HandleImmediateArgs - Handle any arguments which should be

/// treated before building actions or binding tools.

bool HandleImmediateArgs(const Compilation &C);

/// ConstructAction - Construct the appropriate action to do for

/// like -fsyntax-only or --analyze.

Action *ConstructPhaseAction(const ArgList &Args, phases::ID Phase,

Action *Input) const;

/// BuildJobsForAction - Construct the jobs to perform for the

void BuildJobsForAction(Compilation &C,

const Action *A,

const ToolChain *TC,

InputInfo &Result) const;

/// GetNamedOutputPath - Return the name to use for the output of

/// list of temporary or result files, as appropriate.

///

/// \param C - The compilation.

/// addCommand - Append a command to the current job, which must be

/// either a piped job or a job list.

void addCommand(Command *C);

};

/// Command - An executable path/name and argument vector to

static bool classof(const Job *J) {

return J->getKind() == CommandClass;

}

};

/// JobList - A sequence of jobs to perform.

static bool classof(const Job *J) {

return J->getKind() == JobListClass;

}

};

} // end namespace driver

// CC1Option - This option should be accepted by clang -cc1.

def CC1Option : OptionFlag;

// Define the option group class.

class OptionGroup<string name> {

// Define the option class.

string EnumName = ?; // Uses the def name if undefined.

string Name = name;

OptionKind Kind = kind;

// Used by MultiArg option kind.

// Helpers for defining options.

int NumArgs = numargs;

}

// Mix-ins for adding optional attributes.

// FIXME: Have generator validate that these appear in correct position (and

// aren't duplicated).

#include "clang/Basic/LLVM.h"

#include "clang/Driver/OptSpecifier.h"

namespace clang {

namespace driver {

class Arg;

class ArgList;

class InputArgList;

public:

/// \brief Entry for a single option instance in the option data table.

struct Info {

const char *Name;

const char *HelpText;

const char *MetaVar;

unsigned char Kind;

unsigned char Param;

unsigned short Flags;

const Info *OptionInfos;

unsigned NumOptionInfos;

/// 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;

private:

const Info &getInfo(OptSpecifier Opt) const {

unsigned id = Opt.getID();

return OptionInfos[id - 1];

}

protected:

OptTable(const Info *_OptionInfos, unsigned _NumOptionInfos);

public:

/// if necessary.

///

/// \return The option, or null for the INVALID option id.

/// \brief Lookup the name of the given option.

const char *getOptionName(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;

/// \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.

void PrintHelp(raw_ostream &OS, const char *Name,

};

}

}

#ifndef CLANG_DRIVER_OPTION_H_

#define CLANG_DRIVER_OPTION_H_

#include "llvm/ADT/StringRef.h"

#include "clang/Basic/LLVM.h"

namespace clang {

namespace driver {

class Arg;

class ArgList;

/// Option - Abstract representation for a single form of driver

/// argument.

RenderValuesStyle

};

RenderStyleKind getRenderStyle() const {

}

}

/// getUnaliasedOption - Return the final option this option

/// aliases (itself, if the option has no alias).

}

/// getRenderName - Return the name to use when rendering this

/// option.

StringRef getRenderName() const {

}

/// matches - Predicate for whether this option is part of the

/// 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).

void dump() const;

};

} // end namespace driver

namespace options {

enum ID {

OPT_INVALID = 0, // This is not an option ID.

HELPTEXT, METAVAR) OPT_##ID,

#include "clang/Driver/Options.inc"

LastOption

#undef OPTION

};

}

//

// The LLVM Compiler Infrastructure

//

def m_hexagon_Features_Group : OptionGroup<"<m hexagon features group>">, Group<m_Group>;

def opencl_Group : OptionGroup<"<opencl group>">;

def u_Group : OptionGroup<"<u group>">;

def pedantic_Group : OptionGroup<"<pedantic group>">,

Group<CompileOnly_Group>;

Group<ccc_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;

class CCCDriverOpt : Group<ccc_driver_Group>, Flags<[DriverOption, HelpHidden]>;

HelpText<"Act as a C++ driver">;

HelpText<"Echo commands before running them">;

HelpText<"Name for native GCC compiler">,

MetaVarName<"<gcc-path>">;

HelpText<"Comma separate list of architectures to use the clang compiler for">,

MetaVarName<"<arch-list>">;

HelpText<"Use lazy PCH for precompiled headers">;

HelpText<"Use pretokenized headers for precompiled headers">;

class CCCDebugOpt : Group<ccc_debug_Group>, Flags<[DriverOption, HelpHidden]>;

HelpText<"Simulate installation in the given directory">;

HelpText<"Dump parsed command line arguments">;

HelpText<"Dump list of actions to perform">;

HelpText<"Show bindings of tools to actions">;

HelpText<"Check for ARC migration issues that need manual handling">;

HelpText<"Apply modifications to files to conform to ARC">;

HelpText<"Apply modifications and produces temporary files that conform to ARC">;

HelpText<"Output path for the plist report">, Flags<[CC1Option]>;

HelpText<"Emit ARC errors even if the migrator can fix them">,

Flags<[CC1Option]>;

HelpText<"Run the migrator">;

HelpText<"Apply modifications and produces temporary files to migrate to "

"modern ObjC syntax">;

HelpText<"Enable migration to modern ObjC literals">;

HelpText<"Enable migration to modern ObjC subscripting">;

// Make sure all other -ccc- options are rejected.

// Standard Options

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.

HelpText<"Only run the preprocessor">;

HelpText<"Add directory to framework include search path">;

HelpText<"Show header includes and nesting depth">;

HelpText<"Add directory to include search path">;

HelpText<"Add missing headers to dependency list">;

HelpText<"Create phony target for each dependency (other than main file)">;

HelpText<"Specify target to quote for dependency">;

HelpText<"Specify target for dependency">;

HelpText<"Treat source input files as Objective-C++ inputs">;

HelpText<"Treat source input files as Objective-C inputs">;

HelpText<"Disable linemarker output in -E mode">;

HelpText<"Don't emit warning for unused driver arguments">;

HelpText<"Only run preprocess and compilation steps">;

HelpText<"Pass the comma separated arguments in <arg> to the assembler">,

MetaVarName<"<arg>">;

HelpText<"Pass the comma separated arguments in <arg> to the linker">,

MetaVarName<"<arg>">;

Flags<[CC1Option]>;

Flags<[CC1Option]>;

HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,

MetaVarName<"<arg>">;

HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">;

HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">;

HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">,

Flags<[NoForward]>;

HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">;

HelpText<"Pass <arg> to the preprocessor">, MetaVarName<"<arg>">;

HelpText<"OpenCL only. This option allows the compiler to store information about the arguments of a kernel(s)"> ;

HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>,

MetaVarName<"<directory>">;

HelpText<"Only run preprocess, compile, and assemble steps">;

HelpText<"Print macro definitions in -E mode in addition to normal output">;

HelpText<"Print macro definitions in -E mode instead of normal output">;

HelpText<"Filename (or -) to write dependency output to">;

HelpText<"Filename to write DOT-formatted header dependencies to">;

HelpText<"Emit Clang AST files for source inputs">;

HelpText<"Use the LLVM representation for assembler and object files">;

HelpText<"Enable AltiVec vector initializer syntax">;

HelpText<"Use Apple's kernel extensions ABI">;

HelpText<"Enable Apple gcc-compatible #pragma pack handling">;

HelpText<"Enable the 'blocks' language feature">;

HelpText<"Accept non-standard constructs supported by the Borland compiler">;

Group<f_Group>;

HelpText<"Use colors in diagnostics">;

Group<f_Group>;

HelpText<"Enable C++ exceptions">, Flags<[CC1Option]>;

Flags<[CC1Option]>, HelpText<"Print fix-its in machine parseable form">;

Group<f_clang_Group>, Flags<[CC1Option]>,

HelpText<"Print source range spans in numeric form">;

Flags<[CC1Option]>, HelpText<"Print option name with mappable diagnostics">;

Flags<[CC1Option]>, HelpText<"Print diagnostic name">;

Group<f_Group>, Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;

Group<f_Group>, Flags<[CC1Option]>,

HelpText<"Print a template comparison tree for differing templates">;

HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;

Flags<[CC1Option]>,

HelpText<"Do not elide types when printing diagnostics">;

HelpText<"Emit all declarations, even if unused">;

HelpText<"Enable support for exception handling">;

HelpText<"Enable the *frontend*'s 'fast-math' mode. This has no effect on "

"optimizations, but provides a preprocessor macro __FAST_MATH__ the "

HelpText<"Require math functions to indicate errors by setting errno">;

Group<f_Group>;

Group<f_Group>;

// Sic. This option was misspelled originally.

Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"

" | on (according to FP_CONTRACT pragma, default) | off (never fuse)">;

Flags<[CC1Option]>;

HelpText<"Assert that the compilation takes place in a freestanding environment">;

HelpText<"Allow GNU-extension keywords regardless of language standard">;

HelpText<"Use the gnu89 inline semantics">;

HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;

HelpText<"Generate calls to instrument function entry and exit">;

HelpText<"Limit debug information produced to reduce size of debug binary">;

Group<f_Group>;

HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;

HelpText<"Enable support for Microsoft style inine assembly">;

HelpText<"Enable Microsoft compatibility mode">;

HelpText<"Version of the Microsoft C/C++ compiler to report in _MSC_VER (0 = don't define it (default))">;

HelpText<"Parse templated function definitions at the end of the "

"translation unit ">, Flags<[CC1Option]>;

Flags<[NoForward,CC1Option]>, MetaVarName<"<directory>">,

HelpText<"Specify the module cache path">;

HelpText<"Enable the 'modules' language feature">;

HelpText<"Disable C++ access control">;

HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,

Flags<[CC1Option]>;

HelpText<"Disable implicit builtin knowledge of functions">;

Flags<[CC1Option]>;

HelpText<"Compile common globals like normal definitions">;

Flags<[CC1Option]>,

HelpText<"Disable creation of CodeFoundation-type constant strings">;

Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">;

Flags<[CC1Option]>, Group<f_Group>, HelpText<"Display include stacks for diagnostic notes">;

HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;

HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;

HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;

HelpText<"Do not limit debug information produced to reduce size of debug binary">;

HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,

Flags<[CC1Option]>;

HelpText<"Disable generation of rtti information">;

HelpText<"Do not include column number on diagnostics">;

Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;

Flags<[CC1Option]>, HelpText<"Disable spell-checking">;

Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;

HelpText<"Don't use __cxa_atexit for calling destructors">;

HelpText<"Synthesize retain and release calls for Objective-C pointers">;

HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;

HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;

HelpText<"Use GC exclusively for Objective-C related memory management">;

HelpText<"Enable Objective-C garbage collection">;

Group<f_Group>;

HelpText<

"do not infer Objective-C related result type based on method family">,

Flags<[CC1Option]>;

// Objective-C ABI options.

HelpText<"Specify the target Objective-C runtime kind and version">;

HelpText<"Specify the default maximum struct packing alignment">;

HelpText<"Recognize and construct Pascal-style string literals">;

HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;

HelpText<"Force wchar_t to be a short unsigned int">;

HelpText<"Which overload candidates to show when overload resolution fails: "

"best|all; defaults to all">;

HelpText<"Enable optimizations based on the strict definition of an enum's "

Group<f_Group>;

HelpText<"Warn if a function definition returns or accepts an object larger "

// Just silence warnings about -Wlarger-than, -Wframe-larger-than for now.

HelpText<"Trap on integer overflow">;

MetaVarName<"<function name>">,

HelpText<"Issue call to specified function rather than a trap instruction">;

HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;

HelpText<"Give inline C++ member functions default visibility by default">,

Flags<[CC1Option]>;

HelpText<"Treat signed integer overflow as two's complement">;

HelpText<"Store string literals as writable data">;

Flags<[CC1Option]>, HelpText<"Place each function in its own section (ELF Only)">;

HelpText<"Place each data in its own section (ELF Only)">;

HelpText<"Generate source level debug information">, Flags<[CC1Option]>;

HelpText<"Emit debug line number tables only">, Flags<[CC1Option]>;

Group<g_flags_Group>;

HelpText<"Display available options">;

HelpText<"Make the next included directory (-I or -F) an indexer header map">;

HelpText<"Add directory to AFTER include search path">;

HelpText<"Add directory to SYSTEM framework search path">;

HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">;

MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>;

HelpText<"Include precompiled header file">, MetaVarName<"<file>">;

HelpText<"Set the -iwithprefix/-iwithprefixbefore prefix">, MetaVarName<"<dir>">;

HelpText<"Add directory to QUOTE include search path">, MetaVarName<"<directory>">;

HelpText<"Set the system root directory (usually /)">, MetaVarName<"<dir>">;

HelpText<"Add directory to SYSTEM include search path">, MetaVarName<"<directory>">;

HelpText<"Set directory to include search path with prefix">, MetaVarName<"<dir>">,

Flags<[CC1Option]>;

HelpText<"Set directory to SYSTEM include search path with prefix">, MetaVarName<"<dir>">;

HelpText<"Add directory to SYSTEM include search path, "

"absolute paths are relative to -isysroot">, MetaVarName<"<directory>">,

Flags<[CC1Option]>;

HelpText<"Enable hexagon-qdsp6 backward compatibility">;

HelpText<"Additional arguments to forward to LLVM's option processing">;

HelpText<"Set the stack alignment">;

HelpText<"Disable merging of globals">;

HelpText<"(integrated-as) Relax all machine instructions">;

HelpText<"Make StdCall calling convention the default">;

HelpText<"Use software floating point">;

HelpText<"Don't generate implicit floating point instructions">;

HelpText<"Use relative instead of canonical paths">;

HelpText<"Disable builtin #include directories">;

HelpText<"Disable standard #include directories for the C++ standard library">;

HelpText<"Write output to <file>">, MetaVarName<"<file>">;

HelpText<"Use pipes between commands, when possible">;

HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;

HelpText<"Enable Objective-C Ivar layout bitmap print trace">;

HelpText<"Print the library path for \"libgcc.a\"">;

HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">;

HelpText<"Print the paths used for finding libraries and programs">;

HelpText<"Support POSIX threads in generated code">;

HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>;

HelpText<"Rewrite Legacy Objective-C source to C++">;

HelpText<"Save intermediate compilation results">;

HelpText<"Language standard to compile for">;

HelpText<"C++ standard library to use">;

HelpText<"Generate code for the given target">;

HelpText<"Use the gcc toolchain at the given directory">;

HelpText<"Time individual commands">;

HelpText<"Enable some traditional CPP emulation">;

HelpText<"Process trigraph sequences">;

HelpText<"undef all system defines">;

HelpText<"Show commands to run and use verbose output">;

HelpText<"Treat subsequent input files as having type <language>">,

MetaVarName<"<language>">;

HelpText<"Resolve file paths relative to the specified directory">;

Alias<working_directory>;

// Double dash options, which are usually an alias for one of the previous

// options.

HelpText<"Run the static analyzer">;

HelpText<"Serialize compiler diagnostics to a file">;

// Special internal option to handle -Xlinker --no-demangle.

Flags<[Unsupported, NoArgumentUnused]>;

// Special internal option to allow forwarding arbitrary arguments to linker.

Flags<[Unsupported, NoArgumentUnused]>;

// Reserved library options.

Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;

Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;

include "CC1Options.td"

/// driver add an additional "command failed" diagnostic on failures.

virtual bool hasGoodDiagnostics() const { return false; }

///

/// \param TCArgs - The argument list for this toolchain, with any

/// tool chain specific translations applied.

StringRef getPlatform() const { return Triple.getVendorName(); }

StringRef getOS() const { return Triple.getOSName(); }

std::string getTripleString() const {

return Triple.getTriple();

}

return 0;

}

virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,

const ActionList &Inputs) const = 0;

// Helper methods

std::string GetFilePath(const char *Name) const;

// Platform defaults information

/// IsObjCDefaultSynthPropertiesDefault - Does this tool chain enable

/// -fobjc-default-synthesize-properties by default.

virtual bool IsObjCDefaultSynthPropertiesDefault() const { return false; }

/// IsObjCNonFragileABIDefault - Does this tool chain set

/// -fobjc-nonfragile-abi by default.

/// IsUnwindTablesDefault - Does this tool chain use -funwind-tables

/// by default.

/// SupportsProfiling - Does this tool chain support -pg.

virtual bool SupportsProfiling() const { return true; }

/// Does this tool chain support Objective-C garbage collection.

virtual bool SupportsObjCGC() const { return true; }

/// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf

/// compile unit information.

/// for kernel extensions (Darwin-specific).

virtual void AddCCKextLibArgs(const ArgList &Args,

ArgStringList &CmdArgs) const;

};

} // end namespace driver

/// isAcceptedByClang - Can clang handle this input type.

bool isAcceptedByClang(ID Id);

/// isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).

bool isCXX(ID Id);