24326140 upgrade LLVM to 3.8.1
24326159 upgrade clang to 3.8.1
22902339 memory corruption caused by undefined behavior in LLVM IR Module
22777179 implement [ -mtune= -march= -mcpu= ] in clang SPARC
22778085 LLVM is using %icc when it should be using %xcc
22778089 the SPARCV9 IS implementation is incomplete
22778098 LLVM should emit proc identifiers in SPARC assembler (capabilities)
22778650 clang should support OpenMP because it can
22859423 llvm CodeGen on Intel emits a bogus .ctors section
22902355 clang CodeGen is affected by 22902339
23701635 clang produces amd64 opcodes, but calls 32-bit assembler by default
23593143 lli JIT bitcode parsing creates a main function with wrong argc/argv
21759660 clang packages should include the scan-view and scan-build utilities
23854357 clang should check for GNU ld
17867434 clang crashed in LEXER
24306550 clang crashes in llvm::Twine::toStringRef
24311726 clang's Perl and Python utilities should not use #!/usr/bin/env
24312028 llvm::Twine needs copy constructors and assignment operators
24312221 classes must be CopyConstructible, CopyAssignable, MoveConstructible ...
24314621 LLVM should build using the new CMake based build system
24314638 LLVM CommandLine subsystem is busted
24314687 static initialization of optimization passes doesn't work as intended
21870069 clang makes incorrect assumptions about anonymous namespace instantiation order
22643565 llvm's Google test harness needs some attention
24314745 clang should support PIE executables in Solaris
# 24314638 LLVM CommandLine subsystem is busted
# 24314687 static initialization of optimization passes doesn't work as
# intended
# 3.9.X for upstream.
--- include/llvm/Support/raw_ostream.h 2015-12-16 14:59:06.000000000 -0800
+++ include/llvm/Support/raw_ostream.h 2016-05-19 17:27:46.046422643 -0700
@@ -35,7 +35,7 @@
/// output to a stream. It does not support seeking, reopening, rewinding, line
/// buffered disciplines etc. It is a simple buffer that outputs
/// a chunk at a time.
-class raw_ostream {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) raw_ostream {
private:
void operator=(const raw_ostream &) = delete;
raw_ostream(const raw_ostream &) = delete;
###
--- lib/Support/raw_ostream.cpp 2016-01-11 15:33:03.000000000 -0800
+++ lib/Support/raw_ostream.cpp 2016-05-25 20:32:16.532306707 -0700
@@ -20,7 +20,9 @@
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Format.h"
+#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Mutex.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Program.h"
#include <cctype>
@@ -496,7 +498,7 @@
// Handle "-" as stdout. Note that when we do this, we consider ourself
// the owner of stdout. This means that we can do things like close the
// file descriptor when we're done and set the "binary" flag globally.
- if (Filename == "-") {
+ if (Filename == StringRef("-")) {
EC = std::error_code();
// If user requested binary then put stdout into binary mode if
// possible.
@@ -515,38 +517,61 @@
raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
sys::fs::OpenFlags Flags)
- : raw_fd_ostream(getFD(Filename, EC, Flags), true) {}
+ : raw_pwrite_stream(true), FD(-1), ShouldClose(false),
+ Error(false), pos(static_cast<uint64_t>(-1)), SupportsSeeking(false) {
+ this->FD = getFD(Filename, EC, Flags);
+ if (this->FD < 0 ) {
+ ShouldClose = false;
+ return;
+ }
+
+ // Get the starting position.
+ off_t loc = ::lseek(this->FD, 0, SEEK_CUR);
+#ifdef LLVM_ON_WIN32
+ // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
+ sys::fs::file_status Status;
+ std::error_code EC = status(FD, Status);
+ SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
+#else
+ SupportsSeeking = loc != static_cast<off_t>(-1);
+#endif
+ if (!SupportsSeeking)
+ pos = 0ULL;
+ else
+ pos = static_cast<uint64_t>(loc);
+}
/// FD is the file descriptor that this writes to. If ShouldClose is true, this
/// closes the file when the stream is destroyed.
raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
: raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose),
- Error(false) {
- if (FD < 0 ) {
+ Error(false), pos(static_cast<uint64_t>(-1)), SupportsSeeking(false) {
+ if (this->FD < 0 ) {
ShouldClose = false;
return;
}
// Get the starting position.
- off_t loc = ::lseek(FD, 0, SEEK_CUR);
+ off_t loc = ::lseek(this->FD, 0, SEEK_CUR);
#ifdef LLVM_ON_WIN32
// MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
sys::fs::file_status Status;
std::error_code EC = status(FD, Status);
SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
#else
- SupportsSeeking = loc != (off_t)-1;
+ SupportsSeeking = loc != static_cast<off_t>(-1);
#endif
if (!SupportsSeeking)
- pos = 0;
+ pos = 0ULL;
else
pos = static_cast<uint64_t>(loc);
}
raw_fd_ostream::~raw_fd_ostream() {
- if (FD >= 0) {
+ if (this->FD >= 0) {
flush();
- if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(FD))
+
+ if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(this->FD))
error_detected();
}
@@ -585,7 +610,7 @@
if (ChunkSize > 32767 && ShouldWriteInChunks)
ChunkSize = 32767;
- ssize_t ret = ::write(FD, Ptr, ChunkSize);
+ ssize_t ret = ::write(this->FD, Ptr, ChunkSize);
if (ret < 0) {
// If it's a recoverable error, swallow it and retry the write.
@@ -617,11 +642,14 @@
}
void raw_fd_ostream::close() {
- assert(ShouldClose);
+ if (FD == -1) {
+ ShouldClose = false;
+ return;
+ }
+
ShouldClose = false;
flush();
- if (sys::Process::SafelyCloseFileDescriptor(FD))
- error_detected();
+ (void) sys::Process::SafelyCloseFileDescriptor(FD);
FD = -1;
}
@@ -715,30 +743,64 @@
// outs(), errs(), nulls()
//===----------------------------------------------------------------------===//
+static raw_fd_ostream *SOUT = nullptr;
+static llvm::ManagedStatic<llvm::sys::SmartMutex<true> > SOutMutex;
+
+static raw_fd_ostream *SERR = nullptr;
+static llvm::ManagedStatic<llvm::sys::SmartMutex<true> > SErrMutex;
+
+static raw_null_ostream *SNULL = nullptr;
+static llvm::ManagedStatic<llvm::sys::SmartMutex<true> > SNullMutex;
+
/// outs() - This returns a reference to a raw_ostream for standard output.
/// Use it like: outs() << "foo" << "bar";
+__attribute__((noinline))
raw_ostream &llvm::outs() {
// Set buffer settings to model stdout behavior.
// Delete the file descriptor when the program exits, forcing error
// detection. If you don't want this behavior, don't use outs().
- std::error_code EC;
- static raw_fd_ostream S("-", EC, sys::fs::F_None);
- assert(!EC);
- return S;
+ // This makes absolutely no sense whatsoever. getFD returns STDOUT_FILENO
+ // anyway.
+
+ if (!SOUT) {
+ llvm::sys::SmartScopedLock<true> Lock(*SOutMutex);
+ if (!SOUT) {
+ SOUT = new raw_fd_ostream(STDOUT_FILENO, false, false);
+ assert(SOUT);
+ }
+ }
+
+ return *SOUT;
}
/// errs() - This returns a reference to a raw_ostream for standard error.
/// Use it like: errs() << "foo" << "bar";
+__attribute__((noinline))
raw_ostream &llvm::errs() {
// Set standard error to be unbuffered by default.
- static raw_fd_ostream S(STDERR_FILENO, false, true);
- return S;
+ if (!SERR) {
+ llvm::sys::SmartScopedLock<true> Lock(*SErrMutex);
+ if (!SERR) {
+ SERR = new raw_fd_ostream(STDERR_FILENO, false, true);
+ assert(SERR);
+ }
+ }
+
+ return *SERR;
}
/// nulls() - This returns a reference to a raw_ostream which discards output.
+__attribute__((noinline))
raw_ostream &llvm::nulls() {
- static raw_null_ostream S;
- return S;
+ if (!SNULL) {
+ llvm::sys::SmartScopedLock<true> Lock(*SNullMutex);
+ if (!SNULL) {
+ SNULL = new raw_null_ostream();
+ assert(SNULL);
+ }
+ }
+
+ return *SNULL;
}
###
--- include/llvm/Support/CommandLine.h 2015-11-17 10:00:52.000000000 -0900
+++ include/llvm/Support/CommandLine.h 2016-07-05 20:30:35.333194355 -0800
@@ -25,11 +25,13 @@
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <climits>
#include <cstdarg>
#include <utility>
#include <vector>
+#include <type_traits>
namespace llvm {
@@ -111,7 +113,9 @@
// zero reserved for the unspecified value
ValueOptional = 0x01, // The value can appear... or not
ValueRequired = 0x02, // The value is required to appear!
- ValueDisallowed = 0x03 // A value may not be specified (for flags)
+ ValueDisallowed = 0x03, // A value may not be specified (for flags)
+ ValuePositionalNoArgs = 0x04, // Positional Argument, no additional args
+ ValuePositionalWithArgs = 0x05 // Positional Argument, with additional args
};
enum OptionHidden { // Control whether -help shows this option
@@ -149,6 +153,43 @@
};
//===----------------------------------------------------------------------===//
+// Generic Filename Locations
+//
+struct GenericFilenameLocation {
+ GenericFilenameLocation() : Value("") { }
+ GenericFilenameLocation(const std::string &S) : Value(S) { }
+ GenericFilenameLocation(std::string &&S)
+ : Value(std::move(S)) { }
+
+ void operator=(const std::string &S) {
+ if (!S.empty())
+ Value = S;
+ }
+
+ void operator=(std::string &&S) {
+ if (!S.empty())
+ Value = std::move(S);
+ }
+
+ std::string Value;
+};
+
+struct GenericFilenameLocations {
+ GenericFilenameLocations() : Value() { }
+ GenericFilenameLocations(const std::string &S)
+ : Value() {
+ Value.push_back(S);
+ }
+
+ void operator=(const std::string &S) {
+ if (!S.empty())
+ Value.push_back(S);
+ }
+
+ std::vector<std::string> Value;
+};
+
+//===----------------------------------------------------------------------===//
// Option Category class
//
class OptionCategory {
@@ -176,6 +217,16 @@
class alias;
class Option {
friend class alias;
+ friend class OptionRegistry;
+
+protected:
+ /// RegisteredOptionList - This is the list of the command line options
+ /// that have statically constructed themselves.
+ static Option *RegisteredOptionList;
+
+ /// NumRegisteredOptions - The number of Options registered with the
+ /// RegisteredOptionList.
+ static unsigned NumRegisteredOptions;
// handleOccurrences - Overriden by subclasses to handle the value passed into
// an argument. Should return true if there was an error processing the
@@ -191,51 +242,65 @@
// Out of line virtual function to provide home for the class.
virtual void anchor();
- int NumOccurrences; // The number of times specified
+ // The number of times specified
+ int NumOccurrences;
+
// Occurrences, HiddenFlag, and Formatting are all enum types but to avoid
// problems with signed enums in bitfields.
- unsigned Occurrences : 3; // enum NumOccurrencesFlag
+ unsigned Occurrences; // enum NumOccurrencesFlag
+
+ // This Option's position index in the RegisteredOptionList.
+ // -1 means this option hasn't been registered.
+ int OptionIndex;
+
// not using the enum type for 'Value' because zero is an implementation
// detail representing the non-value
- unsigned Value : 2;
- unsigned HiddenFlag : 2; // enum OptionHidden
- unsigned Formatting : 2; // enum FormattingFlags
- unsigned Misc : 3;
+ unsigned Value;
+
+ unsigned HiddenFlag; // enum OptionHidden
+ unsigned Formatting; // enum FormattingFlags
+ unsigned Misc;
unsigned Position; // Position of last occurrence of the option
unsigned AdditionalVals; // Greater than 0 for multi-valued option.
+ Option *NextRegistered;
public:
- StringRef ArgStr; // The argument string itself (ex: "help", "o")
- StringRef HelpStr; // The descriptive text message for -help
- StringRef ValueStr; // String describing what the value of this option is
+ const char *ArgStr; // The argument string itself (ex: "help", "o")
+ const char *HelpStr; // The descriptive text message for -help
+ const char *ValueStr; // String describing what the value of this option is
OptionCategory *Category; // The Category this option belongs to
bool FullyInitialized; // Has addArguemnt been called?
inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
- return (enum NumOccurrencesFlag)Occurrences;
+ return static_cast<enum NumOccurrencesFlag>(Occurrences);
}
+
inline enum ValueExpected getValueExpectedFlag() const {
- return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
+ return Value ?
+ static_cast<enum ValueExpected>(Value) : getValueExpectedFlagDefault();
}
+
inline enum OptionHidden getOptionHiddenFlag() const {
- return (enum OptionHidden)HiddenFlag;
+ return static_cast<enum OptionHidden>(HiddenFlag);
}
+
inline enum FormattingFlags getFormattingFlag() const {
- return (enum FormattingFlags)Formatting;
+ return static_cast<enum FormattingFlags>(Formatting);
}
+
inline unsigned getMiscFlags() const { return Misc; }
inline unsigned getPosition() const { return Position; }
inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
// hasArgStr - Return true if the argstr != ""
- bool hasArgStr() const { return !ArgStr.empty(); }
+ bool hasArgStr() const { return ArgStr && *ArgStr != '\0'; }
//-------------------------------------------------------------------------===
// Accessor functions set by OptionModifiers
//
- void setArgStr(StringRef S);
- void setDescription(StringRef S) { HelpStr = S; }
- void setValueStr(StringRef S) { ValueStr = S; }
+ void setArgStr(const char *S);
+ void setDescription(const char *S) { HelpStr = S; }
+ void setValueStr(const char *S) { ValueStr = S; }
void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
@@ -245,16 +310,121 @@
void setCategory(OptionCategory &C) { Category = &C; }
protected:
+ Option() : NumOccurrences(0),
+ Occurrences(0),
+ OptionIndex(-1),
+ Value(0U),
+ HiddenFlag(0U),
+ Formatting(0U),
+ Misc(0U),
+ Position(0U),
+ AdditionalVals(0U),
+ NextRegistered(nullptr),
+ ArgStr(""),
+ HelpStr(""),
+ ValueStr(""),
+ Category(nullptr),
+ FullyInitialized(false) { }
+
explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
enum OptionHidden Hidden)
- : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
- HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
- AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
- Category(&GeneralCategory), FullyInitialized(false) {}
+ : NumOccurrences(0),
+ Occurrences(OccurrencesFlag),
+ OptionIndex(-1),
+ Value(0U),
+ HiddenFlag(Hidden),
+ Formatting(NormalFormatting),
+ Misc(0U),
+ Position(0U),
+ AdditionalVals(0U),
+ NextRegistered(nullptr),
+ ArgStr(""),
+ HelpStr(""),
+ ValueStr(""),
+ Category(&GeneralCategory),
+ FullyInitialized(false) { }
inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
public:
+ Option(const Option &RHS)
+ : NumOccurrences(RHS.NumOccurrences),
+ Occurrences(RHS.Occurrences),
+ OptionIndex(RHS.OptionIndex),
+ Value(RHS.Value),
+ HiddenFlag(RHS.HiddenFlag),
+ Formatting(RHS.Formatting),
+ Misc(RHS.Misc),
+ Position(RHS.Position),
+ AdditionalVals(RHS.AdditionalVals),
+ NextRegistered(RHS.NextRegistered),
+ ArgStr(RHS.ArgStr),
+ HelpStr(RHS.HelpStr),
+ ValueStr(RHS.ValueStr),
+ Category(RHS.Category),
+ FullyInitialized(RHS.FullyInitialized) { }
+
+ Option(Option &&RHS)
+ : NumOccurrences(std::move(RHS.NumOccurrences)),
+ Occurrences(std::move(RHS.Occurrences)),
+ OptionIndex(std::move(RHS.OptionIndex)),
+ Value(std::move(RHS.Value)),
+ HiddenFlag(std::move(RHS.HiddenFlag)),
+ Formatting(std::move(RHS.Formatting)),
+ Misc(std::move(RHS.Misc)),
+ Position(std::move(RHS.Position)),
+ AdditionalVals(std::move(RHS.AdditionalVals)),
+ NextRegistered(std::move(RHS.NextRegistered)),
+ ArgStr(std::move(RHS.ArgStr)),
+ HelpStr(std::move(RHS.HelpStr)),
+ ValueStr(std::move(RHS.ValueStr)),
+ Category(std::move(RHS.Category)),
+ FullyInitialized(std::move(RHS.FullyInitialized)) { }
+
+ Option &operator=(const Option &RHS) {
+ if (this != &RHS) {
+ NumOccurrences = RHS.NumOccurrences;
+ Occurrences = RHS.Occurrences;
+ OptionIndex = RHS.OptionIndex;
+ Value = RHS.Value;
+ HiddenFlag = RHS.HiddenFlag;
+ Formatting = RHS.Formatting;
+ Misc = RHS.Misc;
+ Position = RHS.Position;
+ AdditionalVals = RHS.AdditionalVals;
+ NextRegistered = RHS.NextRegistered;
+ ArgStr = RHS.ArgStr;
+ HelpStr = RHS.HelpStr;
+ ValueStr = RHS.ValueStr;
+ Category = RHS.Category;
+ FullyInitialized = RHS.FullyInitialized;
+ }
+
+ return *this;
+ }
+
+ const Option &operator=(Option &&RHS) {
+ if (this != &RHS) {
+ NumOccurrences = std::move(RHS.NumOccurrences);
+ Occurrences = std::move(RHS.Occurrences);
+ OptionIndex = RHS.OptionIndex;
+ Value = std::move(RHS.Value);
+ HiddenFlag = std::move(RHS.HiddenFlag);
+ Formatting = std::move(RHS.Formatting);
+ Misc = std::move(RHS.Misc);
+ Position = std::move(RHS.Position);
+ AdditionalVals = std::move(RHS.AdditionalVals);
+ NextRegistered = std::move(RHS.NextRegistered);
+ ArgStr = std::move(RHS.ArgStr);
+ HelpStr = std::move(RHS.HelpStr);
+ ValueStr = std::move(RHS.ValueStr);
+ Category = std::move(RHS.Category);
+ FullyInitialized = std::move(RHS.FullyInitialized);
+ }
+
+ return *this;
+ }
+
// addArgument - Register this argument with the commandline system.
//
void addArgument();
@@ -265,6 +435,32 @@
/// For testing purposes only.
void removeArgument();
+ static void registerOption(Option *O) {
+ assert(O && "Invalid argument!");
+
+ O->NextRegistered = Option::RegisteredOptionList;
+ Option::RegisteredOptionList = O;
+ O->OptionIndex = Option::NumRegisteredOptions;
+ ++Option::NumRegisteredOptions;
+ O->FullyInitialized = true;
+ }
+
+ static Option *getRegisteredOptionList() {
+ return Option::RegisteredOptionList;
+ }
+
+ static unsigned getNumRegisteredOptions() {
+ return Option::NumRegisteredOptions;
+ }
+
+ virtual Option *getNextRegisteredOption() const {
+ if ((OptionIndex == -1) ||
+ (OptionIndex >= static_cast<int>(Option::NumRegisteredOptions)))
+ return nullptr;
+
+ return NextRegistered;
+ }
+
// Return the width of the option tag for printing...
virtual size_t getOptionWidth() const = 0;
@@ -275,13 +471,17 @@
virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
- virtual void getExtraOptionNames(SmallVectorImpl<StringRef> &) {}
+ virtual void getExtraOptionNames(std::vector<const char*> &V) { }
// addOccurrence - Wrapper around handleOccurrence that enforces Flags.
//
virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
bool MultiArg = false);
+ // addOccurrence - Increment the NumOccurrences counter.
+ //
+ virtual void addOccurrence();
+
// Prints option name followed by message. Always returns true.
bool error(const Twine &Message, StringRef ArgName = StringRef());
@@ -298,6 +498,7 @@
// desc - Modifier to set the description shown in the -help output...
struct desc {
const char *Desc;
+ desc() : Desc("") { }
desc(const char *Str) : Desc(Str) {}
void apply(Option &O) const { O.setDescription(Desc); }
};
@@ -306,6 +507,7 @@
// output...
struct value_desc {
const char *Desc;
+ value_desc() : Desc("") { }
value_desc(const char *Str) : Desc(Str) {}
void apply(Option &O) const { O.setValueStr(Desc); }
};
@@ -314,29 +516,37 @@
// the default constructor for the argument type does not give you what you
// want. This is only valid on "opt" arguments, not on "list" arguments.
//
-template <class Ty> struct initializer {
+template<typename Ty> struct initializer {
const Ty &Init;
initializer(const Ty &Val) : Init(Val) {}
+ initializer(const initializer &RHS) : Init(RHS.Init) { }
+ initializer(initializer &&RHS) : Init(RHS.Init) { }
- template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
+ template <typename Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
};
-template <class Ty> initializer<Ty> init(const Ty &Val) {
- return initializer<Ty>(Val);
+template <typename Ty>
+initializer<Ty> init(const Ty &Val) {
+ llvm::cl::initializer<Ty> I(Val);
+ return I;
}
// location - Allow the user to specify which external variable they want to
// store the results of the command line argument processing into, if they don't
// want to store it in the option itself.
//
-template <class Ty> struct LocationClass {
+template <typename Ty> struct LocationClass {
Ty &Loc;
+
LocationClass(Ty &L) : Loc(L) {}
+ LocationClass(const LocationClass &RHS) : Loc(RHS.Loc) { }
+ LocationClass(LocationClass &&RHS) : Loc(RHS.Loc) { }
- template <class Opt> void apply(Opt &O) const { O.setLocation(O, Loc); }
+ template <typename Opt>
+ void apply(Opt &O) const { O.setLocation(O, Loc); }
};
-template <class Ty> LocationClass<Ty> location(Ty &L) {
+template <typename Ty> LocationClass<Ty> location(Ty &L) {
return LocationClass<Ty>(L);
}
@@ -344,43 +554,62 @@
// to.
struct cat {
OptionCategory &Category;
- cat(OptionCategory &c) : Category(c) {}
- template <class Opt> void apply(Opt &O) const { O.setCategory(Category); }
+ cat(OptionCategory &C) : Category(C) { }
+ cat(const cat &RHS) : Category(RHS.Category) { }
+ virtual ~cat() { }
+
+ template<typename Opt>
+ void apply(Opt &O) const { O.setCategory(Category); }
};
//===----------------------------------------------------------------------===//
// OptionValue class
// Support value comparison outside the template.
-struct GenericOptionValue {
+class GenericOptionValue {
+public:
virtual bool compare(const GenericOptionValue &V) const = 0;
protected:
- ~GenericOptionValue() = default;
- GenericOptionValue() = default;
- GenericOptionValue(const GenericOptionValue&) = default;
- GenericOptionValue &operator=(const GenericOptionValue &) = default;
+ virtual ~GenericOptionValue() { }
+ GenericOptionValue() { }
+ GenericOptionValue(const GenericOptionValue &RHS) { }
+ GenericOptionValue(GenericOptionValue &&RHS) { }
+ GenericOptionValue &operator=(const GenericOptionValue &RHS) {
+ return *this;
+ }
+
+ const GenericOptionValue &operator=(GenericOptionValue &&RHS) {
+ return *this;
+ }
private:
virtual void anchor();
};
-template <class DataType> struct OptionValue;
+template<typename DataType, bool> class OptionValue;
// The default value safely does nothing. Option value printing is only
// best-effort.
-template <class DataType, bool isClass>
-struct OptionValueBase : public GenericOptionValue {
+template<typename DataType, bool isClass>
+class OptionValueBase : public GenericOptionValue {
+public:
// Temporary storage for argument passing.
- typedef OptionValue<DataType> WrapperType;
+ typedef OptionValue<DataType, false> WrapperType;
bool hasValue() const { return false; }
- const DataType &getValue() const { llvm_unreachable("no default value"); }
+ const DataType &getValue() const {
+ llvm::errs() << __PRETTY_FUNCTION__ << ": no default value!\n";
+ abort();
+ }
+
+ void setValue(const DataType &V) { }
// Some options may take their value from a different data type.
- template <class DT> void setValue(const DT & /*V*/) {}
+ template<typename DT>
+ void setValue(const DT &V) { }
bool compare(const DataType & /*V*/) const { return false; }
@@ -389,21 +618,55 @@
}
protected:
- ~OptionValueBase() = default;
+ virtual ~OptionValueBase() { }
+
+public:
+ OptionValueBase() : GenericOptionValue() { }
};
// Simple copy of the option value.
-template <class DataType> class OptionValueCopy : public GenericOptionValue {
+template<typename DataType>
+class OptionValueCopy : public GenericOptionValue {
+protected:
DataType Value;
bool Valid;
-protected:
- ~OptionValueCopy() = default;
- OptionValueCopy(const OptionValueCopy&) = default;
- OptionValueCopy &operator=(const OptionValueCopy&) = default;
-
public:
- OptionValueCopy() : Valid(false) {}
+ OptionValueCopy<DataType>()
+ : GenericOptionValue(), Value(), Valid(false) { }
+
+ OptionValueCopy<DataType>(const OptionValueCopy<DataType> &RHS)
+ : GenericOptionValue(RHS), Value(RHS.Value), Valid(RHS.Valid) { }
+
+ OptionValueCopy<DataType>&
+ operator=(const OptionValueCopy<DataType> &RHS) {
+ if (this != &RHS) {
+ GenericOptionValue::operator=(RHS);
+ Value = RHS.Value;
+ Valid = RHS.Valid;
+ }
+
+ return *this;
+ }
+
+ const OptionValueCopy<DataType>&
+ operator=(OptionValueCopy<DataType> &&RHS) {
+ if (this != &RHS) {
+ GenericOptionValue::operator=(RHS);
+ Value = std::move(RHS.Value);
+ Valid = std::move(RHS.Valid);
+ }
+
+ return *this;
+ }
+
+ OptionValueCopy<DataType> &operator=(const DataType& V) {
+ Value = V;
+ Valid = true;
+ return *this;
+ }
+
+ ~OptionValueCopy<DataType>() { }
bool hasValue() const { return Valid; }
@@ -417,6 +680,12 @@
Value = V;
}
+ template<typename DT>
+ void setValue(const DT &V) {
+ Valid = true;
+ Value = V;
+ }
+
bool compare(const DataType &V) const { return Valid && (Value != V); }
bool compare(const GenericOptionValue &V) const override {
@@ -429,117 +698,178 @@
};
// Non-class option values.
-template <class DataType>
-struct OptionValueBase<DataType, false> : OptionValueCopy<DataType> {
+template<typename DataType>
+class OptionValueBase<DataType, false> : public OptionValueCopy<DataType> {
+public:
typedef DataType WrapperType;
protected:
- ~OptionValueBase() = default;
- OptionValueBase() = default;
- OptionValueBase(const OptionValueBase&) = default;
- OptionValueBase &operator=(const OptionValueBase&) = default;
+ virtual ~OptionValueBase<DataType, false>() { }
+
+ OptionValueBase<DataType, false>()
+ : OptionValueCopy<DataType>() { }
+
+ OptionValueBase<DataType, false>(
+ const OptionValueBase<DataType, false> &RHS)
+ : OptionValueCopy<DataType>(RHS) { }
+
+ OptionValueBase<DataType, false>&
+ operator=(const OptionValueBase<DataType, false> &RHS) {
+ if (this != &RHS)
+ OptionValueCopy<DataType>::operator=(RHS);
+
+ return *this;
+ }
+
+ const OptionValueBase<DataType, false>&
+ operator=(OptionValueBase<DataType, false> &&RHS) {
+ if (this != &RHS)
+ OptionValueCopy<DataType>::operator=(RHS);
+
+ return *this;
+ }
+
+ void setValue(const DataType& V) {
+ OptionValueCopy<DataType>::setValue(V);
+ }
+
+ template<typename DT>
+ void setValue(const DT &V) {
+ OptionValueCopy<DataType>::setValue(V);
+ }
};
// Top-level option class.
-template <class DataType>
-struct OptionValue final
- : OptionValueBase<DataType, std::is_class<DataType>::value> {
- OptionValue() = default;
+template<typename DataType, bool IsClass = std::is_class<DataType>::value>
+class OptionValue final :
+ public OptionValueBase<DataType, std::is_class<DataType>::value> {
+public:
+ OptionValue<DataType, IsClass>()
+ : OptionValueBase<DataType, IsClass>() { }
+
+ OptionValue<DataType, IsClass>(const OptionValue<DataType, IsClass> &RHS)
+ : OptionValueBase<DataType, IsClass>(RHS) { }
+
+ OptionValue<DataType, IsClass>&
+ operator=(const OptionValue<DataType, IsClass> &RHS) {
+ if (this != &RHS) {
+ OptionValueBase<DataType, IsClass>::operator=(RHS);
+ }
+
+ return *this;
+ }
+
+ virtual ~OptionValue<DataType, IsClass>() { }
+
+ OptionValue<DataType, IsClass>(const DataType &V)
+ : OptionValueBase<DataType, IsClass>() {
+ OptionValueBase<DataType, IsClass>::setValue(V);
+ }
+
+ void setValue(const DataType &V) {
+ OptionValueBase<DataType, IsClass>::setValue(V);
+ }
+
+ template<typename DT>
+ void setValue(const DT &V) {
+ OptionValueBase<DataType, IsClass>::setValue(V);
+ }
- OptionValue(const DataType &V) { this->setValue(V); }
// Some options may take their value from a different data type.
- template <class DT> OptionValue<DataType> &operator=(const DT &V) {
- this->setValue(V);
+ template<typename DT>
+ OptionValue<DataType, IsClass> &operator=(const DT &V) {
+ // this->setValue(V);
+ OptionValueBase<DataType, IsClass>::setValue(V);
return *this;
}
};
// Other safe-to-copy-by-value common option types.
enum boolOrDefault { BOU_UNSET, BOU_TRUE, BOU_FALSE };
+
template <>
-struct OptionValue<cl::boolOrDefault> final
- : OptionValueCopy<cl::boolOrDefault> {
+class OptionValue<cl::boolOrDefault> final
+ : public OptionValueCopy<cl::boolOrDefault> {
+public:
typedef cl::boolOrDefault WrapperType;
- OptionValue() {}
+ OptionValue<cl::boolOrDefault>()
+ : OptionValueCopy<cl::boolOrDefault>() { }
+
+ OptionValue<cl::boolOrDefault>(const OptionValue<cl::boolOrDefault> &RHS)
+ : OptionValueCopy<cl::boolOrDefault>(RHS) { }
+
+ OptionValue<cl::boolOrDefault>(const cl::boolOrDefault &V)
+ : OptionValueCopy<cl::boolOrDefault>() {
+ this->setValue(V);
+ }
- OptionValue(const cl::boolOrDefault &V) { this->setValue(V); }
OptionValue<cl::boolOrDefault> &operator=(const cl::boolOrDefault &V) {
setValue(V);
return *this;
}
+ OptionValue<cl::boolOrDefault>&
+ operator=(const OptionValue<cl::boolOrDefault> &RHS) {
+ if (this != &RHS) {
+ OptionValueCopy<cl::boolOrDefault>::operator=(RHS);
+ this->setValue(RHS.getValue());
+ }
+
+ return *this;
+ }
+
+ virtual ~OptionValue<cl::boolOrDefault>() { }
+
private:
void anchor() override;
};
template <>
-struct OptionValue<std::string> final : OptionValueCopy<std::string> {
+class OptionValue<std::string> final : public OptionValueCopy<std::string> {
+public:
typedef StringRef WrapperType;
- OptionValue() {}
+ OptionValue<std::string>() : OptionValueCopy<std::string>() { }
+
+ OptionValue<std::string>(const OptionValue<std::string> &RHS)
+ : OptionValueCopy<std::string>(RHS) { }
+
+ OptionValue<std::string>(const std::string &V) {
+ this->setValue(V);
+ }
+
+ OptionValue<std::string>(std::string &&V) {
+ this->setValue(V);
+ }
- OptionValue(const std::string &V) { this->setValue(V); }
OptionValue<std::string> &operator=(const std::string &V) {
+ OptionValueCopy<std::string>::operator=(V);
setValue(V);
return *this;
}
-private:
- void anchor() override;
-};
-
-//===----------------------------------------------------------------------===//
-// Enum valued command line option
-//
-#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, int(ENUMVAL), DESC
-#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, int(ENUMVAL), DESC
-#define clEnumValEnd (reinterpret_cast<void *>(0))
-
-// values - For custom data types, allow specifying a group of values together
-// as the values that go into the mapping that the option handler uses. Note
-// that the values list must always have a 0 at the end of the list to indicate
-// that the list has ended.
-//
-template <class DataType> class ValuesClass {
- // Use a vector instead of a map, because the lists should be short,
- // the overhead is less, and most importantly, it keeps them in the order
- // inserted so we can print our option out nicely.
- SmallVector<std::pair<const char *, std::pair<int, const char *>>, 4> Values;
- void processValues(va_list Vals);
-
-public:
- ValuesClass(const char *EnumName, DataType Val, const char *Desc,
- va_list ValueArgs) {
- // Insert the first value, which is required.
- Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
-
- // Process the varargs portion of the values...
- while (const char *enumName = va_arg(ValueArgs, const char *)) {
- DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
- const char *EnumDesc = va_arg(ValueArgs, const char *);
- Values.push_back(std::make_pair(enumName, // Add value to value map
- std::make_pair(EnumVal, EnumDesc)));
- }
+ const OptionValue<std::string> &operator=(std::string &&V) {
+ OptionValueCopy<std::string>::operator=(V);
+ setValue(V);
+ return *this;
}
- template <class Opt> void apply(Opt &O) const {
- for (size_t i = 0, e = Values.size(); i != e; ++i)
- O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
- Values[i].second.second);
+ OptionValue<std::string> &operator=(const OptionValue<std::string> &RHS) {
+ if (this != &RHS) {
+ OptionValueCopy<std::string>::operator=(RHS);
+ setValue(RHS.getValue());
}
-};
-template <class DataType>
-ValuesClass<DataType> LLVM_END_WITH_NULL
-values(const char *Arg, DataType Val, const char *Desc, ...) {
- va_list ValueArgs;
- va_start(ValueArgs, Desc);
- ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
- va_end(ValueArgs);
- return Vals;
+ return *this;
}
+ virtual ~OptionValue<std::string>() { }
+
+private:
+ void anchor() override;
+};
+
//===----------------------------------------------------------------------===//
// parser class - Parameterizable parser for different data types. By default,
// known data types (string, int, bool) have specialized parsers, that do what
@@ -556,20 +886,73 @@
protected:
class GenericOptionInfo {
public:
+ GenericOptionInfo() : Name(""), HelpStr("") { }
+
GenericOptionInfo(const char *name, const char *helpStr)
: Name(name), HelpStr(helpStr) {}
+
+ GenericOptionInfo(const GenericOptionInfo &RHS)
+ : Name(RHS.Name), HelpStr(RHS.HelpStr) { }
+
+ GenericOptionInfo(GenericOptionInfo &&RHS)
+ : Name(RHS.Name), HelpStr(RHS.HelpStr) { }
+
+ virtual ~GenericOptionInfo() { }
+
+ GenericOptionInfo &operator=(const GenericOptionInfo &RHS) {
+ if (this != &RHS) {
+ Name = RHS.Name;
+ HelpStr = RHS.HelpStr;
+ }
+
+ return *this;
+ }
+
+ const GenericOptionInfo &operator=(GenericOptionInfo &&RHS) {
+ if (this != &RHS) {
+ Name = std::move(RHS.Name);
+ HelpStr = std::move(RHS.HelpStr);
+ }
+
+ return *this;
+ }
+
const char *Name;
const char *HelpStr;
};
+ static Option *DefaultInvalidOption;
+
public:
- generic_parser_base(Option &O) : Owner(O) {}
+ generic_parser_base()
+ : Owner(generic_parser_base::DefaultInvalidOption) { }
+
+ generic_parser_base(Option &O) : Owner(&O) { }
+
+ generic_parser_base(const generic_parser_base &RHS)
+ : Owner(RHS.Owner) { }
+
+ generic_parser_base(generic_parser_base &&RHS)
+ : Owner(RHS.Owner) { }
+
+ virtual ~generic_parser_base() { }
+
+ generic_parser_base &operator=(const generic_parser_base &RHS) {
+ if (this != &RHS)
+ Owner = RHS.Owner;
+
+ return *this;
+ }
- virtual ~generic_parser_base() {} // Base class should have virtual-dtor
+ const generic_parser_base &operator=(generic_parser_base &&RHS) {
+ if (this != &RHS)
+ Owner = std::move(RHS.Owner);
+
+ return *this;
+ }
// getNumOptions - Virtual function implemented by generic subclass to
// indicate how many entries are in Values.
- //
virtual unsigned getNumOptions() const = 0;
// getOption - Return option name N.
@@ -597,19 +980,27 @@
// Template definition ensures that the option and default have the same
// DataType (via the same AnyOptionValue).
template <class AnyOptionValue>
- void printOptionDiff(const Option &O, const AnyOptionValue &V,
+ void printOptionDiff(const Option &O,
+ const AnyOptionValue &V,
const AnyOptionValue &Default,
size_t GlobalWidth) const {
printGenericOptionDiff(O, V, Default, GlobalWidth);
}
- void initialize() {}
+ virtual bool isValid() const {
+ return Owner != DefaultInvalidOption;
+ }
+
+ virtual void initialize() { }
+ virtual void initialize(Option *O) { Owner = O; }
+ virtual void initialize(Option &O) { Owner = &O; }
- void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) {
+ virtual void
+ getExtraOptionNames(std::vector<const char*> &OptionNames) {
// If there has been no argstr specified, that means that we need to add an
// argument for every possible option. This ensures that our options are
// vectored to us.
- if (!Owner.hasArgStr())
+ if (!Owner->hasArgStr())
for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
OptionNames.push_back(getOption(i));
}
@@ -626,7 +1017,7 @@
//
// If this is the case, we cannot allow a value.
//
- if (Owner.hasArgStr())
+ if (Owner->hasArgStr())
return ValueRequired;
else
return ValueDisallowed;
@@ -638,7 +1029,7 @@
unsigned findOption(const char *Name);
protected:
- Option &Owner;
+ Option *Owner;
};
// Default parser implementation - This implementation depends on having a
@@ -647,24 +1038,109 @@
// command line option for -help. Because this is a simple mapping parser, the
// data type can be any unsupported type.
//
-template <class DataType> class parser : public generic_parser_base {
+template<typename DataType>
+class parser : public generic_parser_base {
protected:
class OptionInfo : public GenericOptionInfo {
public:
- OptionInfo(const char *name, DataType v, const char *helpStr)
- : GenericOptionInfo(name, helpStr), V(v) {}
+ OptionInfo() : V() { }
+
+ OptionInfo(const char *Name, DataType DT, const char *HelpStr)
+ : GenericOptionInfo(Name, HelpStr), V(DT) { }
+
+ OptionInfo(const OptionInfo &RHS)
+ : GenericOptionInfo(RHS), V(RHS.V) { }
+
+ OptionInfo(OptionInfo &&RHS)
+ : GenericOptionInfo(RHS), V(RHS.V) { }
+
+ virtual ~OptionInfo() { }
+
+ OptionInfo &operator=(const OptionInfo &RHS) {
+ if (this != &RHS) {
+ GenericOptionInfo::operator=(RHS);
+ V = RHS.V;
+ }
+
+ return *this;
+ }
+
+ const OptionInfo &operator=(OptionInfo &&RHS) {
+ if (this != &RHS) {
+ GenericOptionInfo::operator=(RHS);
+ V = std::move(RHS.V);
+ }
+
+ return *this;
+ }
+
+ OptionInfo &operator=(const OptionValue<DataType> &RHS) {
+ V = RHS;
+ return *this;
+ }
+
+ const OptionInfo &operator=(OptionValue<DataType> &&RHS) {
+ V = std::move(RHS);
+ return *this;
+ }
+
OptionValue<DataType> V;
};
- SmallVector<OptionInfo, 8> Values;
+
+ std::vector<OptionInfo> Values;
public:
- parser(Option &O) : generic_parser_base(O) {}
+ parser<DataType>()
+ : generic_parser_base(), Values() { }
+
+ parser<DataType>(Option &O)
+ : generic_parser_base(O), Values() { }
+
+ parser<DataType>(const parser<DataType> &RHS)
+ : generic_parser_base(RHS), Values(RHS.Values) { }
+
+ parser<DataType>(parser<DataType> &&RHS)
+ : generic_parser_base(RHS), Values(RHS.Values) { }
+
+ virtual ~parser<DataType>() { }
+
+ parser<DataType> &operator=(const parser<DataType> &RHS) {
+ if (this != &RHS) {
+ generic_parser_base::operator=(RHS);
+ Values = RHS.Values;
+ }
+
+ return *this;
+ }
+
+ const parser<DataType> &operator=(parser<DataType> &&RHS) {
+ if (this != &RHS) {
+ generic_parser_base::operator=(RHS);
+ Values = std::move(RHS.Values);
+ }
+
+ return *this;
+ }
+
+ // Why is this needed.
typedef DataType parser_data_type;
// Implement virtual functions needed by generic_parser_base
- unsigned getNumOptions() const override { return unsigned(Values.size()); }
- const char *getOption(unsigned N) const override { return Values[N].Name; }
- const char *getDescription(unsigned N) const override {
+ virtual unsigned getNumOptions() const override {
+ return unsigned(Values.size());
+ }
+
+ virtual const char *getOption(unsigned N) const override {
+ if (N >= Values.size())
+ return 0UL;
+
+ return Values[N].Name;
+ }
+
+ virtual const char *getDescription(unsigned N) const override {
+ if (N >= Values.size())
+ return 0UL;
+
return Values[N].HelpStr;
}
@@ -676,7 +1152,7 @@
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
- if (Owner.hasArgStr())
+ if (Owner->hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
@@ -690,38 +1166,128 @@
return O.error("Cannot find option named '" + ArgVal + "'!");
}
- /// addLiteralOption - Add an entry to the mapping table.
- ///
- template <class DT>
- void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
- assert(findOption(Name) == Values.size() && "Option already exists!");
- OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
- Values.push_back(X);
- AddLiteralOption(Owner, Name);
+ /// addLiteralOption - Add an entry to the mapping table.
+ ///
+ template <typename DT>
+ void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
+ assert(findOption(Name) == Values.size() && "Option already exists!");
+ OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
+ Values.push_back(X);
+ AddLiteralOption(*Owner, Name);
+ }
+
+ void addLiteralOption(const char *Name, const DataType &V,
+ const char *HelpStr) {
+ assert(findOption(Name) == Values.size() && "Option already exists!");
+ OptionInfo X(Name, V, HelpStr);
+ Values.push_back(X);
+ }
+
+ /// removeLiteralOption - Remove the specified option.
+ ///
+ void removeLiteralOption(const char *Name) {
+ unsigned N = findOption(Name);
+ assert(N != Values.size() && "Option not found!");
+ Values.erase(Values.begin() + N);
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
+// Enum valued command line option
+//
+#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, int(ENUMVAL), DESC
+#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, int(ENUMVAL), DESC
+#define clEnumValEnd (reinterpret_cast<void *>(0))
+
+// values - For custom data types, allow specifying a group of values together
+// as the values that go into the mapping that the option handler uses. Note
+// that the values list must always have a 0 at the end of the list to indicate
+// that the list has ended.
+//
+template<typename DataType>
+class ValuesClass {
+ // Use a vector instead of a map, because the lists should be short,
+ // the overhead is less, and most importantly, it keeps them in the order
+ // inserted so we can print our option out nicely.
+ std::vector<std::pair<const char*, std::pair<int, const char*> > > Values;
+ void processValues(va_list Vals);
+
+public:
+ ValuesClass<DataType>(const char *EnumName, DataType Val, const char *Desc,
+ va_list ValueArgs)
+ : Values() {
+ // Insert the first value, which is required.
+ Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
+
+ // Process the varargs portion of the values...
+ while (const char *enumName = va_arg(ValueArgs, const char *)) {
+ DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
+ const char *EnumDesc = va_arg(ValueArgs, const char *);
+
+ Values.push_back(std::make_pair(enumName, // Add value to value map
+ std::make_pair(EnumVal, EnumDesc)));
+ }
+ }
+
+ ValuesClass<DataType>(const ValuesClass<DataType> &RHS)
+ : Values(RHS.Values) { }
+
+ ValuesClass<DataType>(ValuesClass<DataType> &&RHS)
+ : Values(RHS.Values) { }
+
+ ValuesClass<DataType> &operator=(const ValuesClass<DataType> &RHS) {
+ if (this != &RHS)
+ Values.operator=(RHS.Values);
+
+ return *this;
+ }
+
+ const ValuesClass &operator=(ValuesClass<DataType> &&RHS) {
+ if (this != &RHS)
+ Values = std::move(RHS.Values);
+
+ return *this;
}
- /// removeLiteralOption - Remove the specified option.
- ///
- void removeLiteralOption(const char *Name) {
- unsigned N = findOption(Name);
- assert(N != Values.size() && "Option not found!");
- Values.erase(Values.begin() + N);
+ ~ValuesClass() { }
+
+ template<typename Opt>
+ void apply(Opt &O) const {
+ for (size_t i = 0, e = Values.size(); i != e; ++i) {
+ O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
+ Values[i].second.second);
+ }
}
};
+template<typename DataType>
+ValuesClass<DataType> LLVM_END_WITH_NULL
+values(const char *Arg, DataType Val, const char *Desc, ...) {
+ va_list ValueArgs;
+ va_start(ValueArgs, Desc);
+ ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
+ va_end(ValueArgs);
+ return Vals;
+}
+
+//===----------------------------------------------------------------------===//
+
//--------------------------------------------------
// basic_parser - Super class of parsers to provide boilerplate code
//
class basic_parser_impl { // non-template implementation of basic_parser<t>
public:
+ basic_parser_impl() { }
basic_parser_impl(Option &) {}
+ virtual ~basic_parser_impl() { }
enum ValueExpected getValueExpectedFlagDefault() const {
return ValueRequired;
}
- void getExtraOptionNames(SmallVectorImpl<StringRef> &) {}
+ virtual void getExtraOptionNames(std::vector<const char*> &V) { }
void initialize() {}
@@ -744,7 +1310,6 @@
virtual void anchor();
protected:
- ~basic_parser_impl() = default;
// A helper for basic_parser::printOptionDiff.
void printOptionName(const Option &O, size_t GlobalWidth) const;
};
@@ -752,23 +1317,87 @@
// basic_parser - The real basic parser is just a template wrapper that provides
// a typedef for the provided data type.
//
-template <class DataType> class basic_parser : public basic_parser_impl {
+template<typename DataType>
+class basic_parser : public basic_parser_impl {
public:
- basic_parser(Option &O) : basic_parser_impl(O) {}
+ basic_parser<DataType>() : basic_parser_impl(), Values() { }
+ basic_parser<DataType>(Option &O) : basic_parser_impl(O), Values() { }
+ virtual ~basic_parser<DataType>() { }
+
+ virtual unsigned getNumOptions() const {
+ return static_cast<unsigned>(Values.size());
+ }
+
+ virtual const char *getOption(unsigned I) {
+ assert(I < static_cast<unsigned>(Values.size()) &&
+ "Index is out-of-range!");
+ return Values[I].Name;
+ }
+
+ virtual const char *getDescription(unsigned I) {
+ assert(I < static_cast<unsigned>(Values.size()) &&
+ "Index is out-of-range!");
+ return Values[I].Help;
+ }
+
typedef DataType parser_data_type;
typedef OptionValue<DataType> OptVal;
protected:
- // Workaround Clang PR22793
- ~basic_parser() {}
+ template<typename SameDataType>
+ class OptionInfo {
+ public:
+ OptionInfo<SameDataType>()
+ : Name(""), Help(""), V() { }
+
+ OptionInfo<SameDataType>(const char *NameStr, SameDataType DT,
+ const char *HelpStr)
+ : Name(NameStr), Help(HelpStr), V(DT) { }
+
+ OptionInfo<SameDataType>(const OptionInfo<SameDataType> &RHS)
+ : Name(RHS.Name), Help(RHS.Help), V(RHS.V) { }
+
+ OptionInfo<SameDataType>&
+ operator=(const OptionInfo<SameDataType> &RHS) {
+ if (this != &RHS) {
+ Name = RHS.Name;
+ Help = RHS.Help;
+ V = RHS.V;
+ }
+
+ return *this;
+ }
+
+ const OptionInfo<SameDataType>&
+ operator=(OptionInfo<SameDataType> &&RHS) {
+ if (this != &RHS) {
+ Name = std::move(RHS.Name);
+ Help = std::move(RHS.Help);
+ V = std::move(RHS.V);
+ }
+
+ return *this;
+ }
+
+ ~OptionInfo() { }
+
+ const char *Name;
+ const char *Help;
+ OptionValue<SameDataType> V;
+ };
+
+ std::vector<OptionInfo<DataType> > Values;
};
//--------------------------------------------------
// parser<bool>
//
-template <> class parser<bool> final : public basic_parser<bool> {
+template<>
+class parser<bool> final : public basic_parser<bool> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<bool>() : basic_parser<bool>() { }
+ parser<bool>(Option &O) : basic_parser<bool>(O) { }
+ virtual ~parser<bool>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
@@ -782,21 +1411,25 @@
// getValueName - Do not print =<value> at all.
const char *getValueName() const override { return nullptr; }
- void printOptionDiff(const Option &O, bool V, OptVal Default,
+ void printOptionDiff(const Option &O, const bool &V,
+ const llvm::cl::OptionValue<bool> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<bool>;
+// extern template class basic_parser<bool>;
//--------------------------------------------------
// parser<boolOrDefault>
template <>
class parser<boolOrDefault> final : public basic_parser<boolOrDefault> {
public:
- parser(Option &O) : basic_parser(O) {}
+
+ parser<boolOrDefault>() : basic_parser<boolOrDefault>() { }
+ parser<boolOrDefault>(Option &O) : basic_parser<boolOrDefault>(O) { }
+ virtual ~parser<boolOrDefault>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
@@ -808,21 +1441,25 @@
// getValueName - Do not print =<value> at all.
const char *getValueName() const override { return nullptr; }
- void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
+ void printOptionDiff(const Option &O, const boolOrDefault &V,
+ const llvm::cl::OptionValue<boolOrDefault> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<boolOrDefault>;
+// extern template class basic_parser<boolOrDefault>;
//--------------------------------------------------
// parser<int>
//
-template <> class parser<int> final : public basic_parser<int> {
+template<>
+class parser<int> final : public basic_parser<int> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<int>() : basic_parser<int>() { }
+ parser<int>(Option &O) : basic_parser<int>(O) { }
+ virtual ~parser<int>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
@@ -830,21 +1467,29 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "int"; }
- void printOptionDiff(const Option &O, int V, OptVal Default,
+ void addLiteralOption(const char *Name, int V, const char *HelpStr) {
+ OptionInfo<int> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const int &V,
+ const llvm::cl::OptionValue<int> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<int>;
+// extern template class basic_parser<int>;
//--------------------------------------------------
// parser<unsigned>
//
template <> class parser<unsigned> final : public basic_parser<unsigned> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<unsigned>() : basic_parser<unsigned>() { }
+ parser<unsigned>(Option &O) : basic_parser<unsigned>(O) { }
+ virtual ~parser<unsigned>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
@@ -852,14 +1497,20 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "uint"; }
- void printOptionDiff(const Option &O, unsigned V, OptVal Default,
+ void addLiteralOption(const char *Name, unsigned V, const char *HelpStr) {
+ OptionInfo<unsigned> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const unsigned &V,
+ const llvm::cl::OptionValue<unsigned> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<unsigned>;
+// extern template class basic_parser<unsigned>;
//--------------------------------------------------
// parser<unsigned long long>
@@ -868,7 +1519,10 @@
class parser<unsigned long long> final
: public basic_parser<unsigned long long> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<unsigned long long>() : basic_parser<unsigned long long>() { }
+ parser<unsigned long long>(Option &O)
+ : basic_parser<unsigned long long>(O) { }
+ virtual ~parser<unsigned long long>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg,
@@ -877,21 +1531,31 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "uint"; }
- void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
+ void addLiteralOption(const char *Name, unsigned long long V,
+ const char *HelpStr) {
+ OptionInfo<unsigned long long> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const unsigned long long &V,
+ const llvm::cl::OptionValue<unsigned long long> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
void anchor() override;
};
-extern template class basic_parser<unsigned long long>;
+// extern template class basic_parser<unsigned long long>;
//--------------------------------------------------
// parser<double>
//
-template <> class parser<double> final : public basic_parser<double> {
+template<>
+class parser<double> final : public basic_parser<double> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<double>() : basic_parser<double>() { }
+ parser<double>(Option &O) : basic_parser<double>(O) { }
+ virtual ~parser<double>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
@@ -899,21 +1563,31 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "number"; }
- void printOptionDiff(const Option &O, double V, OptVal Default,
+ void addLiteralOption(const char *Name, double V,
+ const char *HelpStr) {
+ OptionInfo<double> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const double &V,
+ const llvm::cl::OptionValue<double> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<double>;
+// extern template class basic_parser<double>;
//--------------------------------------------------
// parser<float>
//
-template <> class parser<float> final : public basic_parser<float> {
+template<>
+class parser<float> final : public basic_parser<float> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<float>() : basic_parser<float>() { }
+ parser<float>(Option &O) : basic_parser<float>(O) { }
+ virtual ~parser<float>() { }
// parse - Return true on error.
bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
@@ -921,21 +1595,31 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "number"; }
- void printOptionDiff(const Option &O, float V, OptVal Default,
+ void addLiteralOption(const char *Name, float V,
+ const char *HelpStr) {
+ OptionInfo<float> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const float &V,
+ const llvm::cl::OptionValue<float> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<float>;
+// extern template class basic_parser<float>;
//--------------------------------------------------
// parser<std::string>
//
-template <> class parser<std::string> final : public basic_parser<std::string> {
+template<>
+class parser<std::string> final : public basic_parser<std::string> {
public:
- parser(Option &O) : basic_parser(O) {}
+ parser<std::string>() : basic_parser<std::string>() { }
+ parser<std::string>(Option &O) : basic_parser<std::string>(O) {}
+ virtual ~parser<std::string>() { }
// parse - Return true on error.
bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
@@ -946,21 +1630,31 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "string"; }
- void printOptionDiff(const Option &O, StringRef V, OptVal Default,
+ void addLiteralOption(const char *Name, const std::string &V,
+ const char *HelpStr) {
+ OptionInfo<std::string> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const std::string &V,
+ const llvm::cl::OptionValue<std::string> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<std::string>;
+// extern template class basic_parser<std::string>;
//--------------------------------------------------
// parser<char>
//
-template <> class parser<char> final : public basic_parser<char> {
+template<>
+class parser<char> final : public basic_parser<char> {
public:
+ parser<char>() : basic_parser<char>() { }
parser(Option &O) : basic_parser(O) {}
+ virtual ~parser<char>() { }
// parse - Return true on error.
bool parse(Option &, StringRef, StringRef Arg, char &Value) {
@@ -971,14 +1665,20 @@
// getValueName - Overload in subclass to provide a better default value.
const char *getValueName() const override { return "char"; }
- void printOptionDiff(const Option &O, char V, OptVal Default,
+ void addLiteralOption(const char *Name, char V, const char *HelpStr) {
+ OptionInfo<char> OI(Name, V, HelpStr);
+ Values.push_back(OI);
+ }
+
+ void printOptionDiff(const Option &O, const char &V,
+ const llvm::cl::OptionValue<char> &Default,
size_t GlobalWidth) const;
// An out-of-line virtual method to provide a 'home' for this class.
- void anchor() override;
+ virtual void anchor() override;
};
-extern template class basic_parser<char>;
+// extern template class basic_parser<char>;
//--------------------------------------------------
// PrintOptionDiff
@@ -987,16 +1687,18 @@
// parser to handle all the template nastiness.
// This overloaded function is selected by the generic parser.
-template <class ParserClass, class DT>
-void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V,
- const OptionValue<DT> &Default, size_t GlobalWidth) {
+template<typename ParserClass, typename DT>
+void printOptionDiff(const Option &O, const generic_parser_base &P,
+ const DT &V, const OptionValue<DT> &Default,
+ size_t GlobalWidth) {
OptionValue<DT> OV = V;
P.printOptionDiff(O, OV, Default, GlobalWidth);
}
// This is instantiated for basic parsers when the parsed value has a different
// type than the option value. e.g. HelpPrinter.
-template <class ParserDT, class ValDT> struct OptionDiffPrinter {
+template<typename ParserDT, typename ValDT>
+struct OptionDiffPrinter {
void print(const Option &O, const parser<ParserDT> &P, const ValDT & /*V*/,
const OptionValue<ValDT> & /*Default*/, size_t GlobalWidth) {
P.printOptionNoValue(O, GlobalWidth);
@@ -1005,7 +1707,8 @@
// This is instantiated for basic parsers when the parsed value has the same
// type as the option value.
-template <class DT> struct OptionDiffPrinter<DT, DT> {
+template<typename DT>
+struct OptionDiffPrinter<DT, DT> {
void print(const Option &O, const parser<DT> &P, const DT &V,
const OptionValue<DT> &Default, size_t GlobalWidth) {
P.printOptionDiff(O, V, Default, GlobalWidth);
@@ -1014,11 +1717,11 @@
// This overloaded function is selected by the basic parser, which may parse a
// different type than the option type.
-template <class ParserClass, class ValDT>
-void printOptionDiff(
- const Option &O,
+template<typename ParserClass, typename ValDT>
+void printOptionDiff(const Option &O,
const basic_parser<typename ParserClass::parser_data_type> &P,
- const ValDT &V, const OptionValue<ValDT> &Default, size_t GlobalWidth) {
+ const ValDT &V, const OptionValue<ValDT> &Default,
+ size_t GlobalWidth) {
OptionDiffPrinter<typename ParserClass::parser_data_type, ValDT> printer;
printer.print(O, static_cast<const ParserClass &>(P), V, Default,
@@ -1031,53 +1734,70 @@
// not correctly respond to the apply method). Because the syntax to use this
// is a pain, we have the 'apply' method below to handle the nastiness...
//
-template <class Mod> struct applicator {
- template <class Opt> static void opt(const Mod &M, Opt &O) { M.apply(O); }
+template<typename Mod>
+struct applicator {
+ template<typename Opt>
+ static void opt(const Mod &M, Opt &O) { M.apply(O); }
};
// Handle const char* as a special case...
-template <unsigned n> struct applicator<char[n]> {
- template <class Opt> static void opt(const char *Str, Opt &O) {
+template<unsigned N>
+struct applicator<char[N]> {
+ template <typename Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
-template <unsigned n> struct applicator<const char[n]> {
+
+template<unsigned N>
+struct applicator<const char[N]> {
template <class Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
-template <> struct applicator<const char *> {
+
+template<>
+struct applicator<const char *> {
template <class Opt> static void opt(const char *Str, Opt &O) {
O.setArgStr(Str);
}
};
-template <> struct applicator<NumOccurrencesFlag> {
+template<>
+struct applicator<NumOccurrencesFlag> {
static void opt(NumOccurrencesFlag N, Option &O) {
O.setNumOccurrencesFlag(N);
}
};
-template <> struct applicator<ValueExpected> {
+
+template<>
+struct applicator<ValueExpected> {
static void opt(ValueExpected VE, Option &O) { O.setValueExpectedFlag(VE); }
};
-template <> struct applicator<OptionHidden> {
+
+template<>
+struct applicator<OptionHidden> {
static void opt(OptionHidden OH, Option &O) { O.setHiddenFlag(OH); }
};
-template <> struct applicator<FormattingFlags> {
+
+template<>
+struct applicator<FormattingFlags> {
static void opt(FormattingFlags FF, Option &O) { O.setFormattingFlag(FF); }
};
-template <> struct applicator<MiscFlags> {
+
+template<>
+struct applicator<MiscFlags> {
static void opt(MiscFlags MF, Option &O) { O.setMiscFlag(MF); }
};
// apply method - Apply modifiers to an option in a type safe way.
-template <class Opt, class Mod, class... Mods>
+template<typename Opt, typename Mod, typename... Mods>
void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
}
-template <class Opt, class Mod> void apply(Opt *O, const Mod &M) {
+template<typename Opt, typename Mod>
+void apply(Opt *O, const Mod &M) {
applicator<Mod>::opt(M, *O);
}
@@ -1088,39 +1808,101 @@
// assumes the user will specify a variable to store the data into with the
// cl::location(x) modifier.
//
-template <class DataType, bool ExternalStorage, bool isClass>
-class opt_storage {
+template<typename DataType, bool ExternalStorage, bool isClass>
+class LLVM_ALIGNAS(8) opt_storage {
+private:
DataType *Location; // Where to store the object...
OptionValue<DataType> Default;
+protected:
void check_location() const {
assert(Location && "cl::location(...) not specified for a command "
"line option with external storage, "
"or cl::init specified before cl::location()!!");
+ if (!Location) {
+ llvm::errs() << __PRETTY_FUNCTION__
+ << ": cl::location(...) not specified for a command "
+ << "line option with external storage, "
+ << "or cl::init specified before cl::location()!!\n";
+ abort();
+ }
}
public:
- opt_storage() : Location(nullptr) {}
+ opt_storage<DataType, ExternalStorage, isClass>()
+ : Location(nullptr), Default() { }
+
+ opt_storage<DataType, ExternalStorage, isClass>(
+ const opt_storage<DataType, ExternalStorage, isClass> &RHS)
+ : Location(RHS.Location), Default(RHS.Default) { }
+
+ opt_storage<DataType, ExternalStorage, isClass>(
+ opt_storage<DataType, ExternalStorage, isClass> &&RHS)
+ : Location(RHS.Location), Default(RHS.Default) { }
+
+ virtual ~opt_storage<DataType, ExternalStorage, isClass>() { }
+
+ opt_storage<DataType, ExternalStorage, isClass>&
+ operator=(const opt_storage<DataType, ExternalStorage, isClass> &RHS) {
+ if (this != &RHS) {
+ Location = RHS.Location;
+ Default = RHS.Default;
+ }
+
+ return *this;
+ }
+
+ const opt_storage<DataType, ExternalStorage, isClass>&
+ operator=(opt_storage<DataType, ExternalStorage, isClass> &&RHS) {
+ if (this != &RHS) {
+ Location = std::move(RHS.Location);
+ Default = std::move(RHS.Default);
+ }
+
+ return *this;
+ }
bool setLocation(Option &O, DataType &L) {
if (Location)
return O.error("cl::location(x) specified more than once!");
+
Location = &L;
Default = L;
return false;
}
- template <class T> void setValue(const T &V, bool initial = false) {
+ void setValue(const DataType &V, bool initial = false) {
check_location();
- *Location = V;
- if (initial)
+
+ DataType *DT =
+ reinterpret_cast<DataType*>(
+ const_cast<void*>(reinterpret_cast<const void*>(&V)));
+ Location = DT;
+
+ if (initial) {
+ Default = V;
+ }
+ }
+
+ template<typename T>
+ void setValue(const T &V, bool initial = false) {
+ check_location();
+
+ DataType *DT =
+ reinterpret_cast<DataType*>(
+ const_cast<void*>(reinterpret_cast<const void*>(&V)));
+ Location = DT;
+
+ if (initial) {
Default = V;
+ }
}
DataType &getValue() {
check_location();
return *Location;
}
+
const DataType &getValue() const {
check_location();
return *Location;
@@ -1134,14 +1916,66 @@
// Define how to hold a class type object, such as a string. Since we can
// inherit from a class, we do so. This makes us exactly compatible with the
// object in all cases that it is used.
-//
-template <class DataType>
-class opt_storage<DataType, false, true> : public DataType {
+template<typename DataType>
+class LLVM_ALIGNAS(8) opt_storage<DataType, false, true> : public DataType {
public:
+ DataType *Location;
OptionValue<DataType> Default;
- template <class T> void setValue(const T &V, bool initial = false) {
+ opt_storage<DataType, false, true>()
+ : DataType(), Location(nullptr), Default() { }
+
+ opt_storage<DataType, false, true>(
+ const opt_storage<DataType, false, true> &RHS)
+ : DataType(RHS), Location(RHS.Location), Default(RHS.Default) { }
+
+ opt_storage<DataType, false, true>(opt_storage<DataType, false, true> &&RHS)
+ : DataType(RHS), Location(RHS.Location), Default(RHS.Default) { }
+
+ virtual ~opt_storage<DataType, false, true>() { }
+
+ opt_storage<DataType, false, true>
+ &operator=(const opt_storage<DataType, false, true> &RHS) {
+ if (this != &RHS) {
+ DataType::operator=(RHS);
+ Location = RHS.Location;
+ Default = RHS.Default;
+ }
+
+ return *this;
+ }
+
+ const opt_storage<DataType, false, true>
+ &operator=(opt_storage<DataType, false, true> &&RHS) {
+ if (this != &RHS) {
+ DataType::operator=(RHS);
+ Location = std::move(RHS.Location);
+ Default = std::move(RHS.Default);
+ }
+
+ return *this;
+ }
+
+ bool setLocation(Option &O, DataType &L) {
+ if (Location)
+ return O.error("cl::location(x) specified more than once!");
+
+ Location = &L;
+ Default = L;
+ return false;
+ }
+
+ void setValue(const DataType &V, bool initial = false) {
DataType::operator=(V);
+
+ if (initial)
+ Default = V;
+ }
+
+ template<typename T>
+ void setValue(const T &V, bool initial = false) {
+ DataType::operator=(V);
+
if (initial)
Default = V;
}
@@ -1155,27 +1989,68 @@
// Define a partial specialization to handle things we cannot inherit from. In
// this case, we store an instance through containment, and overload operators
// to get at the value.
-//
-template <class DataType> class opt_storage<DataType, false, false> {
+template<typename DataType>
+class LLVM_ALIGNAS(8) opt_storage<DataType, false, false> {
public:
DataType Value;
OptionValue<DataType> Default;
// Make sure we initialize the value with the default constructor for the
// type.
- opt_storage() : Value(DataType()), Default(DataType()) {}
+ opt_storage<DataType, false, false>() : Value(), Default() { }
+
+ opt_storage<DataType, false, false>(
+ const opt_storage<DataType, false, false> &RHS)
+ : Value(RHS.Value), Default(RHS.Default) { }
+
+ opt_storage<DataType, false, false>(opt_storage<DataType, false, false> &&RHS)
+ : Value(std::move(RHS.Value)), Default(std::move(RHS.Default)) { }
+
+ opt_storage<DataType, false, false>
+ &operator=(const opt_storage<DataType, false, false> &RHS) {
+ if (this != &RHS) {
+ Value = RHS.Value;
+ Default = RHS.Default;
+ }
+
+ return *this;
+ }
+
+ const opt_storage<DataType, false, false>
+ &operator=(opt_storage<DataType, false, false> &&RHS) {
+ if (this != &RHS) {
+ Value = std::move(RHS.Value);
+ Default = std::move(RHS.Default);
+ }
+
+ return *this;
+ }
- template <class T> void setValue(const T &V, bool initial = false) {
+ bool setLocation(Option &O, DataType &L) {
+ Value = L;
+ Default = Value;
+ return false;
+ }
+
+ void setValue(const DataType &V, bool initial = false) {
+ Value = V;
+ if (initial)
+ Default = V;
+ }
+
+ template<typename T>
+ void setValue(const T &V, bool initial = false) {
Value = V;
if (initial)
Default = V;
}
+
DataType &getValue() { return Value; }
DataType getValue() const { return Value; }
const OptionValue<DataType> &getDefault() const { return Default; }
- operator DataType() const { return getValue(); }
+ operator DataType() const { return Value; }
// If the datatype is a pointer, support -> on it.
DataType operator->() const { return Value; }
@@ -1184,19 +2059,57 @@
//===----------------------------------------------------------------------===//
// opt - A scalar command line option.
//
-template <class DataType, bool ExternalStorage = false,
- class ParserClass = parser<DataType>>
-class opt : public Option,
- public opt_storage<DataType, ExternalStorage,
- std::is_class<DataType>::value> {
+template<typename DataType, bool ExternalStorage = false,
+ typename ParserClass = parser<DataType> >
+class LLVM_ALIGNAS(8) opt : public Option,
+ public opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value> {
ParserClass Parser;
- bool handleOccurrence(unsigned pos, StringRef ArgName,
+public:
+ opt<DataType, ExternalStorage, ParserClass>()
+ : Option(), opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value>(), Parser(*this) { }
+
+ opt<DataType, ExternalStorage, ParserClass>(
+ const opt<DataType, ExternalStorage, ParserClass> &RHS) : Option(RHS),
+ opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value>(RHS), Parser(RHS.Parser) { }
+
+ opt<DataType, ExternalStorage, ParserClass>&
+ operator=(const opt<DataType, ExternalStorage, ParserClass> &RHS) {
+ if (this != &RHS) {
+ Option::operator=(RHS);
+ opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value>::operator=(RHS);
+ Parser = RHS.Parser;
+ }
+
+ return *this;
+ }
+
+ const opt<DataType, ExternalStorage, ParserClass>&
+ operator=(opt<DataType, ExternalStorage, ParserClass> &&RHS) {
+ if (this != &RHS) {
+ Option::operator=(RHS);
+ opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value>::operator=(RHS);
+ Parser = std::move(RHS.Parser);
+ }
+
+ return *this;
+ }
+
+ virtual ~opt<DataType, ExternalStorage, ParserClass>() { }
+
+protected:
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
+
this->setValue(Val);
this->setPosition(pos);
return false;
@@ -1205,7 +2118,9 @@
enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
- void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
+
+ virtual void
+ getExtraOptionNames(std::vector<const char*> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
@@ -1213,6 +2128,7 @@
size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
+
void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
@@ -1229,34 +2145,44 @@
Parser.initialize();
}
- // Command line options should not be copyable
- opt(const opt &) = delete;
- opt &operator=(const opt &) = delete;
-
public:
// setInitialValue - Used by the cl::init modifier...
void setInitialValue(const DataType &V) { this->setValue(V, true); }
+ bool setLocation(Option &O, DataType &L) {
+ bool R = opt_storage<DataType, ExternalStorage,
+ std::is_class<DataType>::value>::setLocation(O, L);
+ return R;
+ }
+
+ void addArgument() {
+ assert(!NextRegistered && "argument multiply registered!");
+ Option::registerOption(this);
+ }
+
ParserClass &getParser() { return Parser; }
- template <class T> DataType &operator=(const T &Val) {
+ template<typename T> DataType &operator=(const T &Val) {
this->setValue(Val);
return this->getValue();
}
- template <class... Mods>
+ template <typename... Mods>
explicit opt(const Mods &... Ms)
- : Option(Optional, NotHidden), Parser(*this) {
+ : Option(Optional, NotHidden),
+ opt_storage<DataType, ExternalStorage, std::is_class<DataType>::value>(),
+ Parser(*this) {
apply(this, Ms...);
done();
}
};
-extern template class opt<unsigned>;
-extern template class opt<int>;
-extern template class opt<std::string>;
-extern template class opt<char>;
-extern template class opt<bool>;
+// extern template class opt<unsigned>;
+// extern template class opt<int>;
+// extern template class opt<std::string>;
+// extern template class opt<char>;
+// extern template class opt<bool>;
+// extern template class opt<unsigned long long>;
//===----------------------------------------------------------------------===//
// list_storage class
@@ -1265,22 +2191,72 @@
// assumes the user will specify a variable to store the data into with the
// cl::location(x) modifier.
//
-template <class DataType, class StorageClass> class list_storage {
+template<typename DataType, typename StorageClass>
+class list_storage {
+private:
StorageClass *Location; // Where to store the object...
public:
- list_storage() : Location(0) {}
+ list_storage<DataType, StorageClass>() : Location(nullptr) { }
+
+ list_storage<DataType, StorageClass>(
+ const list_storage<DataType, StorageClass> &RHS)
+ : Location(RHS.Location) { }
+
+ list_storage<DataType, StorageClass>(
+ list_storage<DataType, StorageClass> &&RHS)
+ : Location(RHS.Location) { }
+
+ virtual ~list_storage<DataType, StorageClass>() { }
+
+ list_storage<DataType, StorageClass>&
+ operator=(const list_storage<DataType, StorageClass> &RHS) {
+ if (this != &RHS)
+ Location = RHS.Location;
+
+ return *this;
+ }
+
+ const list_storage<DataType, StorageClass>&
+ operator=(list_storage<DataType, StorageClass> &&RHS) {
+ if (this != &RHS)
+ Location = std::move(RHS.Location);
+
+ return *this;
+ }
bool setLocation(Option &O, StorageClass &L) {
if (Location)
return O.error("cl::location(x) specified more than once!");
+
Location = &L;
return false;
}
- template <class T> void addValue(const T &V) {
+ void addValue(const DataType &V) {
+ assert(Location != 0 && "cl::location(...) not specified for a command "
+ "line option with external storage!");
+ if (!Location) {
+ llvm::errs() << __PRETTY_FUNCTION__
+ << ": cl::location(...) not specified for a command "
+ << "line option with external storage!\n";
+ abort();
+ }
+
+ Location->push_back(V);
+ }
+
+ template <typename T>
+ void addValue(const T &V) {
assert(Location != 0 && "cl::location(...) not specified for a command "
"line option with external storage!");
+ if (!Location) {
+ llvm::errs() << __PRETTY_FUNCTION__
+ << ": cl::location(...) not specified for a command "
+ << "line option with external storage!\n";
+ abort();
+ }
+
Location->push_back(V);
}
};
@@ -1293,10 +2269,24 @@
//
// FIXME: Reduce this API to a more narrow subset of std::vector
//
-template <class DataType> class list_storage<DataType, bool> {
+template <typename DataType>
+class list_storage<DataType, bool> {
std::vector<DataType> Storage;
public:
+ list_storage<DataType, bool>() : Storage() { }
+ list_storage<DataType, bool>(const list_storage<DataType, bool> &RHS)
+ : Storage(RHS.Storage) { }
+ virtual ~list_storage<DataType, bool>() { }
+
+ list_storage<DataType, bool>
+ &operator=(const list_storage<DataType, bool> &RHS) {
+ if (this != &RHS)
+ Storage = RHS.Storage;
+
+ return *this;
+ }
+
typedef typename std::vector<DataType>::iterator iterator;
iterator begin() { return Storage.begin(); }
@@ -1332,6 +2322,7 @@
iterator insert(const_iterator pos, const DataType &value) {
return Storage.insert(pos, value);
}
+
iterator insert(const_iterator pos, DataType &&value) {
return Storage.insert(pos, value);
}
@@ -1339,6 +2330,7 @@
iterator insert(iterator pos, const DataType &value) {
return Storage.insert(pos, value);
}
+
iterator insert(iterator pos, DataType &&value) {
return Storage.insert(pos, value);
}
@@ -1351,48 +2343,68 @@
std::vector<DataType> *operator&() { return &Storage; }
const std::vector<DataType> *operator&() const { return &Storage; }
- template <class T> void addValue(const T &V) { Storage.push_back(V); }
+ template<typename T>
+ void addValue(const T &V) {
+ T LV(V);
+ Storage.push_back(LV);
+ }
+
+ void addValue(const DataType &V) {
+ DataType LV(V);
+ Storage.push_back(LV);
+ }
+
+ const std::vector<DataType> &getStorage() const {
+ return Storage;
+ }
};
//===----------------------------------------------------------------------===//
// list - A list of command line options.
//
-template <class DataType, class StorageClass = bool,
- class ParserClass = parser<DataType>>
+template<typename DataType, typename StorageClass = bool,
+ typename ParserClass = parser<DataType> >
class list : public Option, public list_storage<DataType, StorageClass> {
+ friend class Option;
std::vector<unsigned> Positions;
ParserClass Parser;
- enum ValueExpected getValueExpectedFlagDefault() const override {
+protected:
+ virtual enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
- void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
+
+ virtual void
+ getExtraOptionNames(std::vector<const char*> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
- bool handleOccurrence(unsigned pos, StringRef ArgName,
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse Error!
- list_storage<DataType, StorageClass>::addValue(Val);
+
+ // list_storage<DataType, StorageClass>::addValue(Val);
+ this->addValue(Val);
setPosition(pos);
Positions.push_back(pos);
return false;
}
// Forward printing stuff to the parser...
- size_t getOptionWidth() const override {
+ virtual size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
- void printOptionInfo(size_t GlobalWidth) const override {
+
+ virtual void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
// Unimplemented: list options don't currently store their default value.
- void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
- }
+ virtual void
+ printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override { }
void done() {
addArgument();
@@ -1400,22 +2412,46 @@
}
// Command line options should not be copyable
- list(const list &) = delete;
- list &operator=(const list &) = delete;
+ list<DataType, StorageClass, ParserClass>(
+ const list<DataType, StorageClass, ParserClass>&) = delete;
+ list<DataType, StorageClass, ParserClass>&
+ operator=(const list<DataType, StorageClass, ParserClass>&) = delete;
public:
+ list<DataType, StorageClass, ParserClass>()
+ : Option(), list_storage<DataType, StorageClass>(),
+ Positions(), Parser(ParserClass()) { }
+
+ list<DataType, StorageClass, ParserClass>(const Option &O)
+ : Option(O), list_storage<DataType, StorageClass>(),
+ Positions(), Parser(ParserClass()) { }
+
+ list<DataType, StorageClass, ParserClass>(Option *O)
+ : Option(*O), list_storage<DataType, StorageClass>(),
+ Positions(), Parser(ParserClass()) { }
+
+ ~list<DataType, StorageClass, ParserClass>() { }
+
ParserClass &getParser() { return Parser; }
+ void addArgument() {
+ assert(!NextRegistered && "argument multiply registered!");
+ Option::registerOption(this);
+ }
+
unsigned getPosition(unsigned optnum) const {
assert(optnum < this->size() && "Invalid option index");
return Positions[optnum];
}
- void setNumAdditionalVals(unsigned n) { Option::setNumAdditionalVals(n); }
+ void setNumAdditionalVals(unsigned N) {
+ Option::setNumAdditionalVals(N);
+ }
- template <class... Mods>
- explicit list(const Mods &... Ms)
- : Option(ZeroOrMore, NotHidden), Parser(*this) {
+ template <typename... Mods>
+ explicit list<DataType, StorageClass, ParserClass>(const Mods &... Ms)
+ : Option(ZeroOrMore, NotHidden), list_storage<DataType, StorageClass>(),
+ Positions(), Parser(*this) {
apply(this, Ms...);
done();
}
@@ -1424,7 +2460,9 @@
// multi_val - Modifier to set the number of additional values.
struct multi_val {
unsigned AdditionalVals;
+ multi_val() : AdditionalVals(0U) { }
explicit multi_val(unsigned N) : AdditionalVals(N) {}
+ ~multi_val() { }
template <typename D, typename S, typename P>
void apply(list<D, S, P> &L) const {
@@ -1439,10 +2477,11 @@
// assumes the user will specify a variable to store the data into with the
// cl::location(x) modifier.
//
-template <class DataType, class StorageClass> class bits_storage {
+template<typename DataType, typename StorageClass>
+class bits_storage {
unsigned *Location; // Where to store the bits...
- template <class T> static unsigned Bit(const T &V) {
+ template<typename T> static unsigned Bit(const T &V) {
unsigned BitPos = reinterpret_cast<unsigned>(V);
assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
@@ -1475,41 +2514,59 @@
// Define how to hold bits. Since we can inherit from a class, we do so.
// This makes us exactly compatible with the bits in all cases that it is used.
//
-template <class DataType> class bits_storage<DataType, bool> {
+template<typename DataType>
+class bits_storage<DataType, bool> {
unsigned Bits; // Where to store the bits...
- template <class T> static unsigned Bit(const T &V) {
- unsigned BitPos = (unsigned)V;
+ template<typename T> static unsigned Bit(const T &V) {
+ unsigned BitPos = static_cast<unsigned>(V);
assert(BitPos < sizeof(unsigned) * CHAR_BIT &&
"enum exceeds width of bit vector!");
return 1 << BitPos;
}
public:
- template <class T> void addValue(const T &V) { Bits |= Bit(V); }
+ void addValue(const DataType &V) {
+ Bits |= Bit(V);
+ }
+
+ template<typename T>
+ void addValue(const T &V) {
+ Bits |= Bit(V);
+ }
unsigned getBits() { return Bits; }
- template <class T> bool isSet(const T &V) { return (Bits & Bit(V)) != 0; }
+ bool isSet(const DataType &V) {
+ return (Bits & Bit(V)) != 0;
+ }
+
+ template<typename T>
+ bool isSet(const T &V) {
+ return (Bits & Bit(V)) != 0;
+ }
};
//===----------------------------------------------------------------------===//
// bits - A bit vector of command options.
//
-template <class DataType, class Storage = bool,
- class ParserClass = parser<DataType>>
+template<typename DataType, typename Storage = bool,
+ typename ParserClass = parser<DataType> >
class bits : public Option, public bits_storage<DataType, Storage> {
std::vector<unsigned> Positions;
ParserClass Parser;
- enum ValueExpected getValueExpectedFlagDefault() const override {
+protected:
+ virtual enum ValueExpected getValueExpectedFlagDefault() const override {
return Parser.getValueExpectedFlagDefault();
}
- void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
+
+ virtual void
+ getExtraOptionNames(std::vector<const char*> &OptionNames) override {
return Parser.getExtraOptionNames(OptionNames);
}
- bool handleOccurrence(unsigned pos, StringRef ArgName,
+ virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
@@ -1525,6 +2582,7 @@
size_t getOptionWidth() const override {
return Parser.getOptionWidth(*this);
}
+
void printOptionInfo(size_t GlobalWidth) const override {
Parser.printOptionInfo(*this, GlobalWidth);
}
@@ -1538,11 +2596,20 @@
Parser.initialize();
}
+private:
// Command line options should not be copyable
- bits(const bits &) = delete;
- bits &operator=(const bits &) = delete;
+ bits<DataType, Storage, ParserClass>(
+ const bits<DataType, Storage, ParserClass>&) = delete;
+ bits<DataType, Storage, ParserClass>
+ &operator=(const bits<DataType, Storage, ParserClass>&) = delete;
public:
+ bits<DataType, Storage, ParserClass>()
+ : Option(ZeroOrMore, NotHidden), bits_storage<DataType, Storage>(),
+ Positions(), Parser() { }
+
+ ~bits() { }
+
ParserClass &getParser() { return Parser; }
unsigned getPosition(unsigned optnum) const {
@@ -1550,9 +2617,10 @@
return Positions[optnum];
}
- template <class... Mods>
- explicit bits(const Mods &... Ms)
- : Option(ZeroOrMore, NotHidden), Parser(*this) {
+ template<typename... Mods>
+ explicit bits<DataType, Storage, ParserClass>(const Mods &... Ms)
+ : Option(ZeroOrMore, NotHidden), bits_storage<DataType, Storage>(),
+ Positions(), Parser(*this) {
apply(this, Ms...);
done();
}
@@ -1568,19 +2636,21 @@
StringRef Arg) override {
return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}
- bool addOccurrence(unsigned pos, StringRef /*ArgName*/, StringRef Value,
- bool MultiArg = false) override {
+
+ virtual bool addOccurrence(unsigned pos, StringRef /*ArgName*/,
+ StringRef Value, bool MultiArg = false) override {
return AliasFor->addOccurrence(pos, AliasFor->ArgStr, Value, MultiArg);
}
+
// Handle printing stuff...
size_t getOptionWidth() const override;
void printOptionInfo(size_t GlobalWidth) const override;
// Aliases do not need to print their values.
- void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
- }
+ virtual void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/)
+ const override { }
- ValueExpected getValueExpectedFlagDefault() const override {
+ virtual ValueExpected getValueExpectedFlagDefault() const override {
return AliasFor->getValueExpectedFlag();
}
@@ -1597,13 +2667,15 @@
alias &operator=(const alias &) = delete;
public:
+ alias() : Option(Optional, Hidden), AliasFor(nullptr) { }
+
void setAliasFor(Option &O) {
if (AliasFor)
error("cl::alias must only have one cl::aliasopt(...) specified!");
AliasFor = &O;
}
- template <class... Mods>
+ template<typename... Mods>
explicit alias(const Mods &... Ms)
: Option(Optional, Hidden), AliasFor(nullptr) {
apply(this, Ms...);
@@ -1615,6 +2687,7 @@
struct aliasopt {
Option &Opt;
explicit aliasopt(Option &O) : Opt(O) {}
+
void apply(alias &A) const { A.setAliasFor(Opt); }
};
@@ -1624,6 +2697,7 @@
// exit is called.
struct extrahelp {
const char *morehelp;
+
explicit extrahelp(const char *help);
};
@@ -1688,7 +2762,7 @@
/// lines and end of the response file to be marked with a nullptr string.
/// \param [out] NewArgv All parsed strings are appended to NewArgv.
void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
- SmallVectorImpl<const char *> &NewArgv,
+ std::vector<const char*> &NewArgv,
bool MarkEOLs = false);
/// \brief Tokenizes a Windows command line which may contain quotes and escaped
@@ -1703,13 +2777,13 @@
/// lines and end of the response file to be marked with a nullptr string.
/// \param [out] NewArgv All parsed strings are appended to NewArgv.
void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
- SmallVectorImpl<const char *> &NewArgv,
+ std::vector<const char*> &NewArgv,
bool MarkEOLs = false);
/// \brief String tokenization function type. Should be compatible with either
/// Windows or Unix command line tokenizers.
typedef void (*TokenizerCallback)(StringRef Source, StringSaver &Saver,
- SmallVectorImpl<const char *> &NewArgv,
+ std::vector<const char*> &NewArgv,
bool MarkEOLs);
/// \brief Expand response files on a command line recursively using the given
@@ -1720,16 +2794,6 @@
/// remaining arguments only until the next end of line, when in a response
/// file.
///
-/// \param [in] Saver Delegates back to the caller for saving parsed strings.
-/// \param [in] Tokenizer Tokenization strategy. Typically Unix or Windows.
-/// \param [in,out] Argv Command line into which to expand response files.
-/// \param [in] MarkEOLs Mark end of lines and the end of the response file
-/// with nullptrs in the Argv vector.
-/// \return true if all @files were expanded successfully or there were none.
-bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
- SmallVectorImpl<const char *> &Argv,
- bool MarkEOLs = false);
-
/// \brief Mark all options not part of this category as cl::ReallyHidden.
///
/// \param Category the category of options to keep displaying
@@ -1748,6 +2812,13 @@
/// option category to display in the -help output.
void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories);
+/// \brief Expand response files on a command line recursively using
+/// the given StringSaver and tokenization strategy.
+///
+bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
+ std::vector<const char *> &Argv,
+ bool MarkEOLs = false);
+
} // End namespace cl
} // End namespace llvm
###
--- lib/Support/CommandLine.cpp 2015-12-28 06:46:15.000000000 -0900
+++ lib/Support/CommandLine.cpp 2016-07-06 13:40:52.605682650 -0800
@@ -34,18 +34,23 @@
#include "llvm/Support/Path.h"
#include "llvm/Support/StringSaver.h"
#include "llvm/Support/raw_ostream.h"
-#include <cstdlib>
-#include <map>
using namespace llvm;
using namespace cl;
+#include <cstdlib>
+#include <string>
+#include <map>
+
#define DEBUG_TYPE "commandline"
+#include <iostream>
+
//===----------------------------------------------------------------------===//
// Template instantiations and anchors.
//
namespace llvm {
namespace cl {
+typedef std::map<std::string, Option*> StdStringMap;
template class basic_parser<bool>;
template class basic_parser<boolOrDefault>;
template class basic_parser<int>;
@@ -82,133 +87,197 @@
//===----------------------------------------------------------------------===//
+namespace llvm {
+ namespace cl {
+ Option *generic_parser_base::DefaultInvalidOption =
+ reinterpret_cast<Option*>(reinterpret_cast<void*>(
+ static_cast<uintptr_t>(0xdeadbeef)));
+ } // namespace cl
+} // namedspace llvm
+
+//===----------------------------------------------------------------------===//
+
namespace {
class CommandLineParser {
public:
// Globals for name and overview of program. Program name is not a string to
// avoid static ctor/dtor issues.
- std::string ProgramName;
- const char *ProgramOverview;
+ static std::string ProgramName;
+ static const char *ProgramOverview;
// This collects additional help to be printed.
- std::vector<const char *> MoreHelp;
+ static std::vector<const char *> MoreHelp;
- SmallVector<Option *, 4> PositionalOpts;
- SmallVector<Option *, 4> SinkOpts;
- StringMap<Option *> OptionsMap;
+ std::vector<Option*> PositionalOpts;
+ std::vector<Option*> SinkOpts;
+ llvm::cl::StdStringMap OptionsMap;
+ StringMap<Option*> ReturnOptionsMap;
Option *ConsumeAfterOpt; // The ConsumeAfter option if it exists.
// This collects the different option categories that have been registered.
SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
- CommandLineParser() : ProgramOverview(nullptr), ConsumeAfterOpt(nullptr) {}
+ // Check out the positional arguments to collect information about them.
+ unsigned NumPositionalRequired;
- void ParseCommandLineOptions(int argc, const char *const *argv,
- const char *Overview);
+ // Determine whether or not there are an unlimited number of positionals
+ bool HasUnlimitedPositionals;
- void addLiteralOption(Option &Opt, const char *Name) {
- if (!Opt.hasArgStr()) {
- if (!OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
- errs() << ProgramName << ": CommandLine Error: Option '" << Name
- << "' registered more than once!\n";
- report_fatal_error("inconsistency in registered CommandLine options");
- }
- }
- }
+ CommandLineParser()
+ : PositionalOpts(), SinkOpts(), OptionsMap(), ReturnOptionsMap(),
+ ConsumeAfterOpt(0UL), RegisteredOptionCategories(),
+ NumPositionalRequired(0U), HasUnlimitedPositionals(false) { }
- void addOption(Option *O) {
- bool HadErrors = false;
- if (O->hasArgStr()) {
- // Add argument to the argument map!
- if (!OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
- errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
- << "' registered more than once!\n";
- HadErrors = true;
- }
- }
+ ~CommandLineParser() { }
- // Remember information about positional options.
- if (O->getFormattingFlag() == cl::Positional)
- PositionalOpts.push_back(O);
- else if (O->getMiscFlags() & cl::Sink) // Remember sink options
- SinkOpts.push_back(O);
- else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
- if (ConsumeAfterOpt) {
- O->error("Cannot specify more than one option with cl::ConsumeAfter!");
- HadErrors = true;
- }
- ConsumeAfterOpt = O;
- }
+ static void GetOptionInfo(std::vector<Option *> &PO,
+ std::vector<Option *> &SO,
+ llvm::cl::StdStringMap &OM);
+
+ static bool ExpandResponseFile(const char *FName,
+ StringSaver &Saver,
+ TokenizerCallback Tokenizer,
+ std::vector<const char *> &NewArgv,
+ bool MarkEOLs = false);
+
+ void __attribute__((noinline))
+ ParseCommandLineOptions(int Argc, const char *const *Argv,
+ const char *Overview);
+
+ void __attribute__((noinline))
+ addLiteralOption(Option &Opt, const char *Name);
+
+ void __attribute__((noinline)) addOption(Option *O);
+
+ void __attribute__((noinline)) removeOption(Option *O);
+
+ bool __attribute__((noinline)) hasOptions();
+
+ void __attribute__((noinline)) updateArgStr(Option *O, StringRef NewName);
+
+ void __attribute__((noinline)) PrintOptionValues();
- // Fail hard if there were errors. These are strictly unrecoverable and
- // indicate serious issues such as conflicting option names or an
- // incorrectly
- // linked LLVM distribution.
- if (HadErrors)
+ void __attribute__((noinline)) registerCategory(OptionCategory *cat);
+
+private:
+ Option *LookupOption(StringRef &Arg, StringRef &Value);
+ void HandleSpecialPrefixOptions(StringRef &ArgName, StringRef &Value);
+};
+
+void __attribute__((noinline))
+CommandLineParser::addLiteralOption(Option &Opt, const char *Name) {
+ if (!Opt.hasArgStr()) {
+ if (!OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
+ errs() << __PRETTY_FUNCTION__ << ": " << ProgramName
+ << ": CommandLine Error: Option '" << Name
+ << "' registered more than once!\n";
report_fatal_error("inconsistency in registered CommandLine options");
+ }
}
+}
- void removeOption(Option *O) {
- SmallVector<StringRef, 16> OptionNames;
- O->getExtraOptionNames(OptionNames);
- if (O->hasArgStr())
- OptionNames.push_back(O->ArgStr);
- for (auto Name : OptionNames)
- OptionsMap.erase(Name);
+void __attribute__((noinline))
+CommandLineParser::addOption(Option *O) {
+ bool HadErrors = false;
+ if (O->hasArgStr()) {
+ // Add argument to the argument map!
+ if (!OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
+ errs() << __PRETTY_FUNCTION__ << ": " << ProgramName
+ << ": CommandLine Error: Option '" << O->ArgStr
+ << "' registered more than once!\n";
+ HadErrors = true;
+ }
+ }
- if (O->getFormattingFlag() == cl::Positional)
- for (auto Opt = PositionalOpts.begin(); Opt != PositionalOpts.end();
- ++Opt) {
- if (*Opt == O) {
- PositionalOpts.erase(Opt);
- break;
- }
+ // Remember information about positional options.
+ if (O->getFormattingFlag() == cl::Positional)
+ PositionalOpts.push_back(O);
+ else if (O->getMiscFlags() & cl::Sink) // Remember sink options
+ SinkOpts.push_back(O);
+ else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
+ if (ConsumeAfterOpt) {
+ O->error("Cannot specify more than one option with cl::ConsumeAfter!");
+ HadErrors = true;
+ }
+
+ ConsumeAfterOpt = O;
+ }
+
+ // Fail hard if there were errors. These are strictly unrecoverable and
+ // indicate serious issues such as conflicting option names or an
+ //incorrectly linked LLVM distribution.
+ if (HadErrors)
+ report_fatal_error("inconsistency in registered CommandLine options");
+}
+
+void __attribute__((noinline))
+CommandLineParser::removeOption(Option *O) {
+ std::vector<const char*> OptionNames;
+ O->getExtraOptionNames(OptionNames);
+ if (O->hasArgStr())
+ OptionNames.push_back(O->ArgStr);
+ for (auto Name : OptionNames)
+ OptionsMap.erase(Name);
+
+ if (O->getFormattingFlag() == cl::Positional) {
+ for (auto Opt = PositionalOpts.begin(); Opt != PositionalOpts.end();
+ ++Opt) {
+ if (*Opt == O) {
+ PositionalOpts.erase(Opt);
+ break;
}
- else if (O->getMiscFlags() & cl::Sink)
- for (auto Opt = SinkOpts.begin(); Opt != SinkOpts.end(); ++Opt) {
- if (*Opt == O) {
- SinkOpts.erase(Opt);
- break;
- }
+ }
+ } else if (O->getMiscFlags() & cl::Sink) {
+ for (auto Opt = SinkOpts.begin(); Opt != SinkOpts.end(); ++Opt) {
+ if (*Opt == O) {
+ SinkOpts.erase(Opt);
+ break;
}
- else if (O == ConsumeAfterOpt)
- ConsumeAfterOpt = nullptr;
+ }
+ } else if (O == ConsumeAfterOpt) {
+ ConsumeAfterOpt = nullptr;
}
+}
- bool hasOptions() {
- return (!OptionsMap.empty() || !PositionalOpts.empty() ||
- nullptr != ConsumeAfterOpt);
- }
+bool __attribute__((noinline))
+CommandLineParser::hasOptions() {
+ return (!OptionsMap.empty() || !PositionalOpts.empty() ||
+ nullptr != ConsumeAfterOpt);
+}
- void updateArgStr(Option *O, StringRef NewName) {
- if (!OptionsMap.insert(std::make_pair(NewName, O)).second) {
- errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
- << "' registered more than once!\n";
- report_fatal_error("inconsistency in registered CommandLine options");
- }
- OptionsMap.erase(O->ArgStr);
+void __attribute__((noinline))
+CommandLineParser::updateArgStr(Option *O, StringRef NewName) {
+ if (!OptionsMap.insert(std::make_pair(NewName, O)).second) {
+ errs() << __PRETTY_FUNCTION__ << ": " << ProgramName
+ << ": CommandLine Error: Option '" << O->ArgStr
+ << "' registered more than once!\n";
+ report_fatal_error("inconsistency in registered CommandLine options");
}
- void printOptionValues();
+ OptionsMap.erase(O->ArgStr);
+}
- void registerCategory(OptionCategory *cat) {
- assert(std::count_if(RegisteredOptionCategories.begin(),
- RegisteredOptionCategories.end(),
- [cat](const OptionCategory *Category) {
- return cat->getName() == Category->getName();
- }) == 0 &&
- "Duplicate option categories");
+void __attribute__((noinline))
+CommandLineParser::registerCategory(OptionCategory *Cat) {
+ assert(std::count_if(RegisteredOptionCategories.begin(),
+ RegisteredOptionCategories.end(),
+ [Cat](const OptionCategory *Category) {
+ return Cat->getName() == Category->getName();
+ }) == 0 && "Duplicate option categories");
- RegisteredOptionCategories.insert(cat);
- }
+ RegisteredOptionCategories.insert(Cat);
+}
-private:
- Option *LookupOption(StringRef &Arg, StringRef &Value);
-};
+std::string CommandLineParser::ProgramName("<premain>");
+const char* CommandLineParser::ProgramOverview = 0L;
+std::vector<const char *> CommandLineParser::MoreHelp;
+
+} // end anonymous namespace
-} // namespace
+llvm::cl::Option* llvm::cl::Option::RegisteredOptionList = nullptr;
+unsigned llvm::cl::Option::NumRegisteredOptions = 0U;
static ManagedStatic<CommandLineParser> GlobalParser;
@@ -222,14 +291,18 @@
void Option::addArgument() {
GlobalParser->addOption(this);
+ Option *O = dynamic_cast<Option*>(this);
+ assert(O && "Cannot dynamic_cast to correct type!");
+ Option::registerOption(O);
+
FullyInitialized = true;
}
void Option::removeArgument() { GlobalParser->removeOption(this); }
-void Option::setArgStr(StringRef S) {
+void Option::setArgStr(const char *S) {
if (FullyInitialized)
- GlobalParser->updateArgStr(this, S);
+ GlobalParser->updateArgStr(this, StringRef(S));
ArgStr = S;
}
@@ -244,6 +317,107 @@
// Basic, shared command line option processing machinery.
//
+/// HandleSpecialPrefixOptions - certain options need special handling
+/// of their Argyment/Value pair, because there will be no space separator
+/// between the two. For example -O<N> (optimization level).
+void CommandLineParser::HandleSpecialPrefixOptions(StringRef &ArgName,
+ StringRef &Value) {
+ if (ArgName.empty())
+ return;
+
+ const char *ArgStr = ArgName.data();
+ bool DoSubstitution;
+
+ if (ArgStr[0] == 'O' && ArgStr[1] == '\0')
+ DoSubstitution = true;
+ else if (ArgStr[0] == 'O' && std::isalpha(ArgStr[1]) && ArgStr[2] == '\0')
+ DoSubstitution = true;
+ else if (ArgStr[0] == 'O' && std::isdigit(ArgStr[1]) && ArgStr[2] == '\0')
+ DoSubstitution = true;
+ else if (ArgStr[0] == 'g' && ArgStr[1] == '\0')
+ DoSubstitution = true;
+ else if (ArgStr[0] == 'g' && std::isdigit(ArgStr[1]) && ArgStr[2] == '\0')
+ DoSubstitution = true;
+ else
+ DoSubstitution = false;
+
+ if (DoSubstitution) {
+ Value = ArgName.substr(1, 1);
+ ArgName = ArgName.substr(0, 1);
+ }
+}
+
+/// GetOptionInfo - Scan the list of registered options, turning them into data
+/// structures that are easier to handle.
+void CommandLineParser::GetOptionInfo(std::vector<Option *> &PO,
+ std::vector<Option *> &SO,
+ llvm::cl::StdStringMap &OM) {
+ bool HadErrors = false;
+ std::vector<const char *> OptionNames;
+ Option *CAOpt = nullptr; // The ConsumeAfter option if it exists.
+
+ for (Option *O = Option::getRegisteredOptionList(); O;
+ O = O->getNextRegisteredOption()) {
+ // If this option wants to handle multiple option names, get the full set.
+ // This handles enum options like "-O1 -O2" etc.
+ O->getExtraOptionNames(OptionNames);
+
+ if (O->ArgStr && *O->ArgStr)
+ OptionNames.push_back(O->ArgStr);
+
+ llvm::cl::StdStringMap::iterator FI;
+
+ // Handle named options.
+ for (size_t i = 0, e = OptionNames.size(); i != e; ++i) {
+ // Add argument to the argument map!
+ FI = OM.find(OptionNames[i]);
+ if (FI == OM.end()) {
+ if (!OM.insert(std::make_pair(OptionNames[i], O)).second) {
+ errs() << __PRETTY_FUNCTION__ << ": " << ProgramName.c_str()
+ << ": CommandLine Error: Option '" << OptionNames[i]
+ << "' insertion failed!\n";
+ HadErrors = true;
+ }
+ } else {
+ if (FI->second != O) {
+ errs() << __PRETTY_FUNCTION__ << ": " << ProgramName.c_str()
+ << ": CommandLine Error: Option '"
+ << OptionNames[i] << "' registered more than once!\n";
+ HadErrors = true;
+ }
+ }
+ }
+
+ OptionNames.clear();
+
+ // Remember information about positional options.
+ if (O->getFormattingFlag() == cl::Positional)
+ PO.push_back(O);
+ else if (O->getMiscFlags() & cl::Sink) // Remember sink options
+ SO.push_back(O);
+ else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
+ if (CAOpt) {
+ O->error("Cannot specify more than one option with cl::ConsumeAfter!");
+ HadErrors = true;
+ }
+
+ CAOpt = O;
+ }
+ }
+
+ if (CAOpt)
+ PO.push_back(CAOpt);
+
+ // Make sure that they are in order of registration not backwards.
+ std::reverse(PO.begin(), PO.end());
+
+ // Fail hard if there were errors. These are strictly unrecoverable and
+ // indicate serious issues such as conflicting option names or an incorrectly
+ // linked LLVM distribution.
+ if (HadErrors)
+ report_fatal_error("inconsistency in registered CommandLine options");
+}
+
/// LookupOption - Lookup the option specified by the specified option on the
/// command line. If there is a value specified (after an equal sign) return
/// that as well. This assumes that leading dashes have already been stripped.
@@ -252,18 +426,89 @@
if (Arg.empty())
return nullptr;
+ HandleSpecialPrefixOptions(Arg, Value);
+
size_t EqualPos = Arg.find('=');
// If we have an equals sign, remember the value.
if (EqualPos == StringRef::npos) {
+ StringRef LookupString;
+
// Look up the option.
- StringMap<Option *>::const_iterator I = OptionsMap.find(Arg);
+ llvm::cl::StdStringMap::const_iterator I = OptionsMap.find(Arg);
+
+ // TableGen
+ if (I == OptionsMap.end()) {
+ LookupString = "<input file>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ // lli && llc
+ if (I == OptionsMap.end()) {
+ LookupString = "<input bitcode>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ // opt
+ if (I == OptionsMap.end()) {
+ LookupString = "<input bitcode file>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "Output filename";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "Output Filename";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "<Output filename>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "<Output Filename>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "output filename";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
+ if (I == OptionsMap.end()) {
+ LookupString = "<output filename>";
+ I = OptionsMap.find(LookupString);
+ if (I != OptionsMap.end())
+ return I->second;
+ }
+
return I != OptionsMap.end() ? I->second : nullptr;
}
// If the argument before the = is a valid option name, we match. If not,
// return Arg unmolested.
- StringMap<Option *>::const_iterator I =
+ llvm::cl::StdStringMap::const_iterator I =
OptionsMap.find(Arg.substr(0, EqualPos));
if (I == OptionsMap.end())
return nullptr;
@@ -278,7 +523,7 @@
/// (after an equal sign) return that as well. This assumes that leading dashes
/// have already been stripped.
static Option *LookupNearestOption(StringRef Arg,
- const StringMap<Option *> &OptionsMap,
+ const llvm::cl::StdStringMap &OptionsMap,
std::string &NearestString) {
// Reject all dashes.
if (Arg.empty())
@@ -292,11 +537,10 @@
// Find the closest match.
Option *Best = nullptr;
unsigned BestDistance = 0;
- for (StringMap<Option *>::const_iterator it = OptionsMap.begin(),
- ie = OptionsMap.end();
- it != ie; ++it) {
+ for (llvm::cl::StdStringMap::const_iterator it = OptionsMap.begin(),
+ ie = OptionsMap.end(); it != ie; ++it) {
Option *O = it->second;
- SmallVector<StringRef, 16> OptionNames;
+ std::vector<const char*> OptionNames;
O->getExtraOptionNames(OptionNames);
if (O->hasArgStr())
OptionNames.push_back(O->ArgStr);
@@ -351,21 +595,33 @@
/// ProvideOption - For Value, this differentiates between an empty value ("")
/// and a null value (StringRef()). The later is accepted for arguments that
/// don't allow a value (-foo) the former is rejected (-foo=).
-static inline bool ProvideOption(Option *Handler, StringRef ArgName,
- StringRef Value, int argc,
- const char *const *argv, int &i) {
+static bool ProvideOption(Option *Handler, StringRef &ArgName,
+ StringRef &Value, int Argc,
+ const char *const *Argv, int &i) {
// Is this a multi-argument option?
unsigned NumAdditionalVals = Handler->getNumAdditionalVals();
+ std::string AS = ArgName.str();
+ std::string VS = Value.str();
+
+ if (AS.find("version") != std::string::npos)
+ Value = "true";
+ else if (VS.find("help") != std::string::npos)
+ Value = "true";
+
+ VS = Value.str();
+
// Enforce value requirements
switch (Handler->getValueExpectedFlag()) {
case ValueRequired:
- if (!Value.data()) { // No value specified?
- if (i + 1 >= argc)
- return Handler->error("requires a value!");
+ if (Value.empty()) { // No value specified?
+ if ((i + 1) >= Argc)
+ return Handler->error("argument requires a value!");
+
// Steal the next argument, like for '-o filename'
- assert(argv && "null check");
- Value = argv[++i];
+ assert(Argv && "null check");
+
+ Value = Argv[++i];
}
break;
case ValueDisallowed:
@@ -373,12 +629,18 @@
return Handler->error("multi-valued option specified"
" with ValueDisallowed modifier!");
- if (Value.data())
+ if (!Value.empty())
return Handler->error("does not allow a value! '" + Twine(Value) +
"' specified.");
break;
case ValueOptional:
break;
+ case ValuePositionalNoArgs:
+ case ValuePositionalWithArgs:
+ break;
+ default:
+ return Handler->error("Unknown/invalid Option type!");
+ break;
}
// If this isn't a multi-arg option, just run the handler.
@@ -388,30 +650,43 @@
// If it is, run the handle several times.
bool MultiArg = false;
- if (Value.data()) {
+ if (!Value.empty()) {
if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
return true;
+
--NumAdditionalVals;
MultiArg = true;
}
while (NumAdditionalVals > 0) {
- if (i + 1 >= argc)
+ if ((i + 1) >= Argc)
return Handler->error("not enough values!");
- assert(argv && "null check");
- Value = argv[++i];
+
+ assert(Argv && "null check");
+ Value = Argv[++i];
if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
return true;
+
MultiArg = true;
--NumAdditionalVals;
}
+
return false;
}
static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
int Dummy = i;
- return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy);
+ StringRef ArgStr = Handler->ArgStr;
+ bool R = ProvideOption(Handler, ArgStr, Arg, 0, nullptr, Dummy);
+ return R;
+}
+
+static bool ProvidePositionalOptionWithArgs(Option *Handler, StringRef Arg,
+ int i, unsigned &ValNo,
+ unsigned &NumPositionsRequired) {
+ // FIXME: IMPLEMENT
+ return false;
}
// Option predicates...
@@ -430,9 +705,9 @@
//
static Option *getOptionPred(StringRef Name, size_t &Length,
bool (*Pred)(const Option *),
- const StringMap<Option *> &OptionsMap) {
+ const llvm::cl::StdStringMap &OptionsMap) {
- StringMap<Option *>::const_iterator OMI = OptionsMap.find(Name);
+ llvm::cl::StdStringMap::const_iterator OMI = OptionsMap.find(Name);
// Loop while we haven't found an option and Name still has at least two
// characters in it (so that the next iteration will not be the empty
@@ -454,9 +729,9 @@
/// see if this is a prefix or grouped option. If so, split arg into output an
/// Arg/Value pair and return the Option to parse it with.
static Option *
-HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value,
+HandlePrefixedOrGroupedOption(std::string &Arg, std::string &Value,
bool &ErrorParsing,
- const StringMap<Option *> &OptionsMap) {
+ const llvm::cl::StdStringMap &OptionsMap) {
if (Arg.size() == 1)
return nullptr;
@@ -489,9 +764,10 @@
// we don't need to pass argc/argv in.
assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired &&
"Option can not be cl::Grouping AND cl::ValueRequired!");
+
int Dummy = 0;
- ErrorParsing |=
- ProvideOption(PGOpt, OneArgName, StringRef(), 0, nullptr, Dummy);
+ StringRef ES = "";
+ ErrorParsing |= ProvideOption(PGOpt, OneArgName, ES, 0, nullptr, Dummy);
// Get the next grouping option.
PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap);
@@ -507,8 +783,12 @@
}
static bool EatsUnboundedNumberOfValues(const Option *O) {
- return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
- O->getNumOccurrencesFlag() == cl::OneOrMore;
+ return O->getNumOccurrencesFlag() == cl::Required ||
+ O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
+ O->getNumOccurrencesFlag() == cl::OneOrMore ||
+ O->getValueExpectedFlag() == cl::ValueRequired ||
+ O->getValueExpectedFlag() == cl::ValuePositionalNoArgs ||
+ O->getValueExpectedFlag() == cl::ValuePositionalWithArgs;
}
static bool isWhitespace(char C) { return strchr(" \t\n\r\f\v", C); }
@@ -518,7 +798,7 @@
static bool isGNUSpecial(char C) { return strchr("\\\"\' ", C); }
void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver,
- SmallVectorImpl<const char *> &NewArgv,
+ std::vector<const char*> &NewArgv,
bool MarkEOLs) {
SmallString<128> Token;
for (size_t I = 0, E = Src.size(); I != E; ++I) {
@@ -594,7 +874,8 @@
/// consumed in this case.
///
/// * Otherwise, backslashes are interpreted literally.
-static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) {
+static size_t parseBackslash(StringRef Src, size_t I,
+ SmallString<512> &Token) {
size_t E = Src.size();
int BackslashCount = 0;
// Skip the backslashes.
@@ -616,9 +897,9 @@
}
void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver,
- SmallVectorImpl<const char *> &NewArgv,
+ std::vector<const char*> &NewArgv,
bool MarkEOLs) {
- SmallString<128> Token;
+ SmallString<512> Token;
// This is a small state machine to consume characters until it reaches the
// end of the source string.
@@ -699,14 +980,16 @@
return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
}
-static bool ExpandResponseFile(const char *FName, StringSaver &Saver,
+bool CommandLineParser::ExpandResponseFile(const char *FName,
+ StringSaver &Saver,
TokenizerCallback Tokenizer,
- SmallVectorImpl<const char *> &NewArgv,
- bool MarkEOLs = false) {
+ std::vector<const char *> &NewArgv,
+ bool MarkEOLs) {
ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
MemoryBuffer::getFile(FName);
if (!MemBufOrErr)
return false;
+
MemoryBuffer &MemBuf = *MemBufOrErr.get();
StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
@@ -730,10 +1013,13 @@
return true;
}
-/// \brief Expand response files on a command line recursively using the given
-/// StringSaver and tokenization strategy.
-bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
- SmallVectorImpl<const char *> &Argv,
+namespace llvm {
+ namespace cl {
+ /// \brief Expand response files on a command line recursively using
+ /// the given StringSaver and tokenization strategy.
+ bool ExpandResponseFiles(StringSaver &Saver,
+ TokenizerCallback Tokenizer,
+ std::vector<const char *> &Argv,
bool MarkEOLs) {
unsigned RspFiles = 0;
bool AllExpanded = true;
@@ -741,37 +1027,43 @@
// Don't cache Argv.size() because it can change.
for (unsigned I = 0; I != Argv.size();) {
const char *Arg = Argv[I];
+
// Check if it is an EOL marker
if (Arg == nullptr) {
++I;
continue;
}
+
if (Arg[0] != '@') {
++I;
continue;
}
- // If we have too many response files, leave some unexpanded. This avoids
- // crashing on self-referential response files.
+ // If we have too many response files, leave some unexpanded.
+ // This avoids crashing on self-referential response files.
if (RspFiles++ > 20)
return false;
// Replace this response file argument with the tokenization of its
- // contents. Nested response files are expanded in subsequent iterations.
- // FIXME: If a nested response file uses a relative path, is it relative to
- // the cwd of the process or the response file?
- SmallVector<const char *, 0> ExpandedArgv;
- if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv,
- MarkEOLs)) {
- // We couldn't read this file, so we leave it in the argument stream and
- // move on.
+ // contents. Nested response files are expanded in subsequent
+ // iterations.
+ // FIXME: If a nested response file uses a relative path, is it
+ // relative to the cwd of the process or the response file?
+ std::vector<const char*> ExpandedArgv;
+ if (!CommandLineParser::ExpandResponseFile(Arg + 1, Saver, Tokenizer,
+ ExpandedArgv, MarkEOLs)) {
+ // We couldn't read this file, so we leave it in the argument stream
+ // and move on.
AllExpanded = false;
++I;
continue;
}
+
Argv.erase(Argv.begin() + I);
- Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end());
+ Argv.insert(Argv.begin() + I, ExpandedArgv.begin(),
+ ExpandedArgv.end());
}
+
return AllExpanded;
}
@@ -780,7 +1072,7 @@
/// from the caller (as PROGNAME) and its command-line arguments from
/// an environment variable (whose name is given in ENVVAR).
///
-void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
+ void ParseEnvironmentOptions(const char *progName, const char *envVar,
const char *Overview) {
// Check args.
assert(progName && "Program name not specified");
@@ -793,53 +1085,65 @@
// Get program's "name", which we wouldn't know without the caller
// telling us.
- SmallVector<const char *, 20> newArgv;
+ std::vector<const char*> NewArgv;
BumpPtrAllocator A;
StringSaver Saver(A);
- newArgv.push_back(Saver.save(progName));
+ NewArgv.push_back(Saver.save(progName));
// Parse the value of the environment variable into a "command line"
// and hand it off to ParseCommandLineOptions().
- TokenizeGNUCommandLine(envValue, Saver, newArgv);
- int newArgc = static_cast<int>(newArgv.size());
- ParseCommandLineOptions(newArgc, &newArgv[0], Overview);
+ TokenizeGNUCommandLine(envValue, Saver, NewArgv);
+ int NewArgc = static_cast<int>(NewArgv.size());
+ ParseCommandLineOptions(NewArgc, &NewArgv[0], Overview);
}
-void cl::ParseCommandLineOptions(int argc, const char *const *argv,
+ void ParseCommandLineOptions(int Argc, const char *const *Argv,
const char *Overview) {
- GlobalParser->ParseCommandLineOptions(argc, argv, Overview);
+ GlobalParser->ParseCommandLineOptions(Argc, Argv, Overview);
}
+ } // end namespace cl
+} // end namespace llvm
-void CommandLineParser::ParseCommandLineOptions(int argc,
- const char *const *argv,
- const char *Overview) {
- assert(hasOptions() && "No options specified!");
-
+void __attribute__((noinline))
+CommandLineParser::ParseCommandLineOptions(int Argc,
+ const char *const *Argv,
+ const char *Overview) {
// Expand response files.
- SmallVector<const char *, 20> newArgv(argv, argv + argc);
+ std::vector<const char*> NewArgv;
+ for (int i = 0; i != Argc; ++i)
+ NewArgv.push_back(Argv[i]);
+
+ // You have no clue what's wrong with this, do you. Time for some
+ // cargo-cult programming. Make up a new and useless class, throw
+ // in a new allocator for no valid reason and hope for the best,
+ // without inasmuch as an inkling as to what is wrong with all of
+ // this code to begin with.
BumpPtrAllocator A;
StringSaver Saver(A);
- ExpandResponseFiles(Saver, TokenizeGNUCommandLine, newArgv);
- argv = &newArgv[0];
- argc = static_cast<int>(newArgv.size());
+ llvm::cl::ExpandResponseFiles(Saver, TokenizeGNUCommandLine, NewArgv);
+ Argv = &NewArgv[0];
+ Argc = static_cast<int>(NewArgv.size());
// Copy the program name into ProgName, making sure not to overflow it.
- ProgramName = sys::path::filename(argv[0]);
+ CommandLineParser::ProgramName = sys::path::filename(Argv[0]);
ProgramOverview = Overview;
bool ErrorParsing = false;
- // Check out the positional arguments to collect information about them.
- unsigned NumPositionalRequired = 0;
-
- // Determine whether or not there are an unlimited number of positionals
- bool HasUnlimitedPositionals = false;
+ CommandLineParser::GetOptionInfo(PositionalOpts, SinkOpts, OptionsMap);
+ assert(hasOptions() && "No options specified!");
if (ConsumeAfterOpt) {
assert(PositionalOpts.size() > 0 &&
"Cannot specify cl::ConsumeAfter without a positional argument!");
}
+
if (!PositionalOpts.empty()) {
+ if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) {
+ assert(PositionalOpts.size() > 1 &&
+ "Cannot specify cl::ConsumeAfter without a positional argument!");
+ ConsumeAfterOpt = PositionalOpts[0];
+ }
// Calculate how many positional values are _required_.
bool UnboundedFound = false;
@@ -850,12 +1154,12 @@
else if (ConsumeAfterOpt) {
// ConsumeAfter cannot be combined with "optional" positional options
// unless there is only one positional argument...
- if (PositionalOpts.size() > 1)
+ if (PositionalOpts.size() > 2)
ErrorParsing |= Opt->error(
"error - this positional option will never be matched, "
"because it does not Require a value, and a "
"cl::ConsumeAfter option is active!");
- } else if (UnboundedFound && !Opt->hasArgStr()) {
+ } else if (UnboundedFound && !Opt->ArgStr[0]) {
// This option does not "require" a value... Make sure this option is
// not specified after an option that eats all extra arguments, or this
// one will never get any!
@@ -864,19 +1168,21 @@
"another positional argument will match an "
"unbounded number of values, and this option"
" does not require a value!");
- errs() << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr
- << "' is all messed up!\n";
+ errs() << ProgramName << ": CommandLine Error: Option '"
+ << Opt->ArgStr << "' is all messed up!\n";
errs() << PositionalOpts.size();
}
+
UnboundedFound |= EatsUnboundedNumberOfValues(Opt);
}
+
HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
}
// PositionalVals - A vector of "positional" arguments we accumulate into
// the process at the end.
//
- SmallVector<std::pair<StringRef, unsigned>, 4> PositionalVals;
+ std::vector<std::pair<StringRef, unsigned> > PositionalVals;
// If the program has named positional arguments, and the name has been run
// across, keep track of which positional argument was named. Otherwise put
@@ -885,40 +1191,51 @@
// Loop over all of the arguments... processing them.
bool DashDashFound = false; // Have we read '--'?
- for (int i = 1; i < argc; ++i) {
+ for (int i = 1; i < Argc; ++i) {
Option *Handler = nullptr;
Option *NearestHandler = nullptr;
std::string NearestHandlerString;
- StringRef Value;
+ StringRef Value = "";
StringRef ArgName = "";
// Check to see if this is a positional argument. This argument is
// considered to be positional if it doesn't start with '-', if it is "-"
// itself, or if we have seen "--" already.
//
- if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
+ if (((Argv[i][0] != '-') && (Argv[i][1] != '\0')) ||
+ ((Argv[i][0] == '-') && (Argv[i][1] == '\0')) || DashDashFound) {
// Positional argument!
if (ActivePositionalArg) {
- ProvidePositionalOption(ActivePositionalArg, argv[i], i);
+ ProvidePositionalOption(ActivePositionalArg, Argv[i], i);
+ continue; // We are done!
+ }
+
+ ArgName = Argv[i - 1];
+ Value = Argv[i];
+ Handler = LookupOption(ArgName, Value);
+ if (Handler && (Handler->getValueExpectedFlag() == cl::ValueRequired ||
+ Handler->getValueExpectedFlag() == cl::ValueOptional)) {
+ ErrorParsing |= ProvideOption(Handler, ArgName, Value,
+ Argc, Argv, i);
continue; // We are done!
}
if (!PositionalOpts.empty()) {
- PositionalVals.push_back(std::make_pair(argv[i], i));
+ PositionalVals.push_back(std::make_pair(Argv[i], i));
// All of the positional arguments have been fulfulled, give the rest to
// the consume after option... if it's specified...
//
if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {
- for (++i; i < argc; ++i)
- PositionalVals.push_back(std::make_pair(argv[i], i));
+ for (++i; i < Argc; ++i)
+ PositionalVals.push_back(std::make_pair(Argv[i], i));
break; // Handle outside of the argument processing loop...
}
// Delay processing positional arguments until the end...
continue;
}
- } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
+ } else if (Argv[i][0] == '-' && Argv[i][1] == '-' && Argv[i][2] == 0 &&
!DashDashFound) {
DashDashFound = true; // This is the mythical "--"?
continue; // Don't try to process it as an argument itself.
@@ -927,29 +1244,65 @@
// If there is a positional argument eating options, check to see if this
// option is another positional argument. If so, treat it as an argument,
// otherwise feed it to the eating positional.
- ArgName = argv[i] + 1;
+ ArgName = Argv[i] + 1;
+
// Eat leading dashes.
while (!ArgName.empty() && ArgName[0] == '-')
ArgName = ArgName.substr(1);
Handler = LookupOption(ArgName, Value);
+ if (Handler && (Handler->getValueExpectedFlag() == cl::ValueRequired ||
+ Handler->getValueExpectedFlag() == cl::ValueOptional)) {
+ ErrorParsing |= ProvideOption(Handler, ArgName, Value,
+ Argc, Argv, i);
+ continue; // We are done!
+ }
+
if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
- ProvidePositionalOption(ActivePositionalArg, argv[i], i);
+ ProvidePositionalOption(ActivePositionalArg, Argv[i], i);
continue; // We are done!
}
} else { // We start with a '-', must be an argument.
- ArgName = argv[i] + 1;
+ ArgName = Argv[i];
+
// Eat leading dashes.
while (!ArgName.empty() && ArgName[0] == '-')
ArgName = ArgName.substr(1);
Handler = LookupOption(ArgName, Value);
+ if (Handler) {
+ enum FormattingFlags FF = Handler->getFormattingFlag();
+ enum ValueExpected VEF = Handler->getValueExpectedFlag();
+
+ if ((FF == llvm::cl::Prefix) || (FF == llvm::cl::Grouping)) {
+ if (Value.empty())
+ Value = Argv[++i];
+
+ std::string SA = ArgName.str();
+ std::string SV = Value.str();
+ SA.append(SV);
+
+ // Check to see if this "option" is really a prefixed or
+ // grouped argument.
+ Option *PrefixOrGroupHandler =
+ HandlePrefixedOrGroupedOption(SA, SV, ErrorParsing, OptionsMap);
+ if (PrefixOrGroupHandler)
+ Handler = PrefixOrGroupHandler;
+ } else if (VEF == llvm::cl::ValueRequired) {
+ ErrorParsing |= ProvideOption(Handler, ArgName, Value, Argc,
+ Argv, i);
+ continue; // We are done!
+ }
+ }
// Check to see if this "option" is really a prefixed or grouped argument.
- if (!Handler)
- Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing,
+ if (!Handler) {
+ std::string SA = ArgName.str();
+ std::string SV = Value.str();
+ Handler = HandlePrefixedOrGroupedOption(SA, SV, ErrorParsing,
OptionsMap);
+ }
// Otherwise, look for the closest available option to report to the user
// in the upcoming error.
@@ -960,8 +1313,8 @@
if (!Handler) {
if (SinkOpts.empty()) {
- errs() << ProgramName << ": Unknown command line argument '" << argv[i]
- << "'. Try: '" << argv[0] << " -help'\n";
+ errs() << ProgramName << ": Unknown command line argument '" << Argv[i]
+ << "'. Try: '" << Argv[0] << " -help'\n";
if (NearestHandler) {
// If we know a near match, report it as well.
@@ -971,10 +1324,9 @@
ErrorParsing = true;
} else {
- for (SmallVectorImpl<Option *>::iterator I = SinkOpts.begin(),
- E = SinkOpts.end();
- I != E; ++I)
- (*I)->addOccurrence(i, "", argv[i]);
+ for (std::vector<Option*>::iterator I = SinkOpts.begin(),
+ E = SinkOpts.end(); I != E; ++I)
+ (*I)->addOccurrence(i, "", Argv[i]);
}
continue;
}
@@ -984,7 +1336,7 @@
if (Handler->getFormattingFlag() == cl::Positional)
ActivePositionalArg = Handler;
else
- ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
+ ErrorParsing |= ProvideOption(Handler, ArgName, Value, Argc, Argv, i);
}
// Check and handle positional arguments now...
@@ -992,59 +1344,85 @@
errs() << ProgramName
<< ": Not enough positional command line arguments specified!\n"
<< "Must specify at least " << NumPositionalRequired
- << " positional arguments: See: " << argv[0] << " -help\n";
+ << " positional arguments: See: " << Argv[0] << " -help\n";
ErrorParsing = true;
} else if (!HasUnlimitedPositionals &&
PositionalVals.size() > PositionalOpts.size()) {
errs() << ProgramName << ": Too many positional arguments specified!\n"
<< "Can specify at most " << PositionalOpts.size()
- << " positional arguments: See: " << argv[0] << " -help\n";
+ << " positional arguments: See: " << Argv[0] << " -help\n";
ErrorParsing = true;
} else if (!ConsumeAfterOpt) {
// Positional args have already been handled if ConsumeAfter is specified.
- unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());
+ unsigned ValNo = 0;
+ unsigned NumVals = static_cast<unsigned>(PositionalVals.size());
for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
- if (RequiresValue(PositionalOpts[i])) {
+ Option *PO = PositionalOpts[i];
+ if (RequiresValue(PO)) {
ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
ValNo++;
--NumPositionalRequired; // We fulfilled our duty...
}
+ enum llvm::cl::ValueExpected VE = PO->getValueExpectedFlag();
+
+ // If it's a positional argument, provide it
+ if ((NumVals - ValNo) > NumPositionalRequired) {
+ if (VE == llvm::cl::ValuePositionalNoArgs) {
+ ProvidePositionalOption(PO, PositionalVals[ValNo].first,
+ PositionalVals[ValNo].second);
+ ++ValNo;
+ --NumPositionalRequired;
+ continue;
+ } else if (VE == llvm::cl::ValuePositionalWithArgs) {
+ ProvidePositionalOptionWithArgs(PO, PositionalVals[ValNo].first,
+ PositionalVals[ValNo].second,
+ ValNo,
+ NumPositionalRequired);
+ continue;
+ }
+ }
+
// If we _can_ give this option more arguments, do so now, as long as we
// do not give it values that others need. 'Done' controls whether the
// option even _WANTS_ any more.
//
- bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
- while (NumVals - ValNo > NumPositionalRequired && !Done) {
- switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
+ bool Done =
+ ((PO->getNumOccurrencesFlag() == cl::Required) &&
+ (VE != llvm::cl::ValuePositionalNoArgs));
+
+ while (((NumVals - ValNo) > NumPositionalRequired) && !Done) {
+ switch (PO->getNumOccurrencesFlag()) {
case cl::Optional:
Done = true; // Optional arguments want _at most_ one value
// FALL THROUGH
case cl::ZeroOrMore: // Zero or more will take all they can get...
case cl::OneOrMore: // One or more will take all they can get...
- ProvidePositionalOption(PositionalOpts[i],
- PositionalVals[ValNo].first,
+ ProvidePositionalOption(PO, PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
ValNo++;
break;
default:
- llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
+ assert(0 && "Internal Compiler Error: "
+ "unexpected NumOccurrences flag in "
"positional argument processing!");
+ break;
}
}
}
} else {
- assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
+ assert(ConsumeAfterOpt && (NumPositionalRequired <= PositionalVals.size()));
unsigned ValNo = 0;
- for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j)
- if (RequiresValue(PositionalOpts[j])) {
- ErrorParsing |= ProvidePositionalOption(PositionalOpts[j],
- PositionalVals[ValNo].first,
+ for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) {
+ Option *PO = PositionalOpts[j];
+ if (RequiresValue(PO)) {
+ ErrorParsing |= ProvidePositionalOption(PO, PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
- ValNo++;
+ ++ValNo;
+ }
}
// Handle the case where there is just one positional option, and it's
@@ -1052,11 +1430,11 @@
// positional option and keep the rest for the consume after. The above
// loop would have assigned no values to positional options in this case.
//
- if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) {
- ErrorParsing |= ProvidePositionalOption(PositionalOpts[0],
+ if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) {
+ ErrorParsing |= ProvidePositionalOption(PositionalOpts[1],
PositionalVals[ValNo].first,
PositionalVals[ValNo].second);
- ValNo++;
+ ++ValNo;
}
// Handle over all of the rest of the arguments to the
@@ -1076,7 +1454,7 @@
Opt.second->error("must be specified at least once!");
ErrorParsing = true;
}
- // Fall through
+ break;
default:
break;
}
@@ -1086,8 +1464,8 @@
// Note that if ReadResponseFiles == true, this must be done before the
// memory allocated for the expanded command line is free()d below.
DEBUG(dbgs() << "Args: ";
- for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' ';
- dbgs() << '\n';);
+ for (int i = 0; i < Argc; ++i)
+ dbgs() << Argv[i] << ' '; dbgs() << '\n';);
// Free all of the memory allocated to the map. Command line options may only
// be processed once!
@@ -1119,7 +1497,8 @@
if (!MultiArg)
NumOccurrences++; // Increment the number of times we have been seen
- switch (getNumOccurrencesFlag()) {
+ llvm::cl::NumOccurrencesFlag NOF = getNumOccurrencesFlag();
+ switch (NOF) {
case Optional:
if (NumOccurrences > 1)
return error("may only occur zero or one times!", ArgName);
@@ -1134,16 +1513,28 @@
break;
}
- return handleOccurrence(pos, ArgName, Value);
+ std::string SAN = ArgName;
+ std::string SV = Value;
+
+ bool R = handleOccurrence(pos, SAN.c_str(), SV.c_str());
+ return R;
+}
+
+void Option::addOccurrence() {
+ ++NumOccurrences;
}
// getValueStr - Get the value description string, using "DefaultMsg" if nothing
// has been specified yet.
//
static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
- if (O.ValueStr.empty())
+ if (!O.ValueStr)
+ return DefaultMsg;
+
+ if (O.ValueStr == '\0')
return DefaultMsg;
- return O.ValueStr;
+
+ return StringRef(O.ValueStr);
}
//===----------------------------------------------------------------------===//
@@ -1151,7 +1542,10 @@
//
// Return the width of the option tag for printing...
-size_t alias::getOptionWidth() const { return ArgStr.size() + 6; }
+size_t alias::getOptionWidth() const {
+ StringRef ArgStrRef(ArgStr);
+ return ArgStrRef.size() + 6;
+}
static void printHelpStr(StringRef HelpStr, size_t Indent,
size_t FirstLineIndentedBy) {
@@ -1166,7 +1560,8 @@
// Print out the option for the alias.
void alias::printOptionInfo(size_t GlobalWidth) const {
outs() << " -" << ArgStr;
- printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);
+ StringRef ArgStrRef(ArgStr);
+ printHelpStr(HelpStr, GlobalWidth, ArgStrRef.size() + 6);
}
//===----------------------------------------------------------------------===//
@@ -1178,7 +1573,8 @@
// Return the width of the option tag for printing...
size_t basic_parser_impl::getOptionWidth(const Option &O) const {
- size_t Len = O.ArgStr.size();
+ StringRef ArgStrRef(O.ArgStr);
+ size_t Len = ArgStrRef.size();
if (const char *ValName = getValueName())
Len += getValueStr(O, ValName).size() + 3;
@@ -1190,10 +1586,28 @@
//
void basic_parser_impl::printOptionInfo(const Option &O,
size_t GlobalWidth) const {
+ const char *ArgStr = O.ArgStr ? O.ArgStr : "";
+ bool PrintValue;
+
+ if (ArgStr[0] == 'O' && ArgStr[1] == '\0')
+ PrintValue = false;
+ else if (ArgStr[0] == 'O' && std::isalpha(ArgStr[1]) && ArgStr[2] == '\0')
+ PrintValue = false;
+ else if (ArgStr[0] == 'O' && std::isdigit(ArgStr[1]) && ArgStr[2] == '\0')
+ PrintValue = false;
+ else if (ArgStr[0] == 'g' && ArgStr[1] == '\0')
+ PrintValue = false;
+ else if (ArgStr[0] == 'g' && std::isdigit(ArgStr[1]) && ArgStr[2] == '\0')
+ PrintValue = false;
+ else
+ PrintValue = true;
+
outs() << " -" << O.ArgStr;
- if (const char *ValName = getValueName())
- outs() << "=<" << getValueStr(O, ValName) << '>';
+ if (const char *ValName = getValueName()) {
+ if (PrintValue)
+ outs() << "=<" << getValueStr(O, ValName) << '>';
+ }
printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
}
@@ -1201,7 +1615,8 @@
void basic_parser_impl::printOptionName(const Option &O,
size_t GlobalWidth) const {
outs() << " -" << O.ArgStr;
- outs().indent(GlobalWidth - O.ArgStr.size());
+ StringRef ArgStrRef(O.ArgStr);
+ outs().indent(GlobalWidth - ArgStrRef.size());
}
// parser<bool> implementation
@@ -1315,7 +1730,8 @@
// Return the width of the option tag for printing...
size_t generic_parser_base::getOptionWidth(const Option &O) const {
if (O.hasArgStr()) {
- size_t Size = O.ArgStr.size() + 6;
+ StringRef ArgStrRef(O.ArgStr);
+ size_t Size = ArgStrRef.size() + 6;
for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
Size = std::max(Size, std::strlen(getOption(i)) + 8);
return Size;
@@ -1334,7 +1750,8 @@
size_t GlobalWidth) const {
if (O.hasArgStr()) {
outs() << " -" << O.ArgStr;
- printHelpStr(O.HelpStr, GlobalWidth, O.ArgStr.size() + 6);
+ StringRef ArgStrRef(O.ArgStr);
+ printHelpStr(O.HelpStr, GlobalWidth, ArgStrRef.size() + 6);
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
size_t NumSpaces = GlobalWidth - strlen(getOption(i)) - 8;
@@ -1342,7 +1759,8 @@
outs().indent(NumSpaces) << " - " << getDescription(i) << '\n';
}
} else {
- if (!O.HelpStr.empty())
+ StringRef HelpStrRef(O.HelpStr);
+ if (!HelpStrRef.empty())
outs() << " " << O.HelpStr << '\n';
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
const char *Option = getOption(i);
@@ -1361,7 +1779,8 @@
const Option &O, const GenericOptionValue &Value,
const GenericOptionValue &Default, size_t GlobalWidth) const {
outs() << " -" << O.ArgStr;
- outs().indent(GlobalWidth - O.ArgStr.size());
+ StringRef ArgStrRef(O.ArgStr);
+ outs().indent(GlobalWidth - ArgStrRef.size());
unsigned NumOpts = getNumOptions();
for (unsigned i = 0; i != NumOpts; ++i) {
@@ -1387,7 +1806,8 @@
// printOptionDiff - Specializations for printing basic value types.
//
#define PRINT_OPT_DIFF(T) \
- void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \
+ void llvm::cl::parser<T>::printOptionDiff(const Option &O, const T &V, \
+ const llvm::cl::OptionValue<T> &D, \
size_t GlobalWidth) const { \
printOptionName(O, GlobalWidth); \
std::string Str; \
@@ -1406,6 +1826,30 @@
outs() << ")\n"; \
}
+#if 0
+void
+llvm::cl::parser<bool>::printOptionDiff(const Option &O, bool V,
+ const llvm::cl::OptionValue<bool> &D,
+ size_t GlobalWidth) const {
+ printOptionName(O, GlobalWidth);
+ std::string Str;
+ {
+ raw_string_ostream SS(Str);
+ SS << V;
+ }
+ outs() << "= " << Str;
+ size_t NumSpaces =
+ MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0;
+ outs().indent(NumSpaces) << " (default: ";
+ if (D.hasValue())
+ outs() << D.getValue();
+ else
+ outs() << "*no default*";
+ outs() << ")\n";
+}
+#endif
+
+
PRINT_OPT_DIFF(bool)
PRINT_OPT_DIFF(boolOrDefault)
PRINT_OPT_DIFF(int)
@@ -1415,11 +1859,13 @@
PRINT_OPT_DIFF(float)
PRINT_OPT_DIFF(char)
-void parser<std::string>::printOptionDiff(const Option &O, StringRef V,
- OptionValue<std::string> D,
+void
+parser<std::string>::printOptionDiff(const Option &O,
+ const std::string &V,
+ const llvm::cl::OptionValue<std::string> &D,
size_t GlobalWidth) const {
printOptionName(O, GlobalWidth);
- outs() << "= " << V;
+ outs() << "= " << V.c_str();
size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;
outs().indent(NumSpaces) << " (default: ";
if (D.hasValue())
@@ -1439,19 +1885,21 @@
//===----------------------------------------------------------------------===//
// -help and -help-hidden option implementation
//
-
-static int OptNameCompare(const std::pair<const char *, Option *> *LHS,
- const std::pair<const char *, Option *> *RHS) {
- return strcmp(LHS->first, RHS->first);
+template<typename Ty>
+struct OptNameCompare : public std::binary_function<Ty, Ty, bool> {
+ inline bool operator()(const Ty& LHS, const Ty& RHS) const {
+ return std::strcmp(LHS.first, RHS.first) <= 0;
}
+};
// Copy Options into a vector so we can sort them as we like.
-static void sortOpts(StringMap<Option *> &OptMap,
- SmallVectorImpl<std::pair<const char *, Option *>> &Opts,
+static void sortOpts(llvm::cl::StdStringMap &OptMap,
+ std::vector<std::pair<const char *, Option *>> &Opts,
bool ShowHidden) {
- SmallPtrSet<Option *, 128> OptionSet; // Duplicate option detection.
+ SmallPtrSet<Option *, 256> OptionSet; // Duplicate option detection.
+ // Uh-huh. Really? Where is it used?
- for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
+ for (llvm::cl::StdStringMap::iterator I = OptMap.begin(), E = OptMap.end();
I != E; ++I) {
// Ignore really-hidden options.
if (I->second->getOptionHiddenFlag() == ReallyHidden)
@@ -1465,21 +1913,29 @@
if (!OptionSet.insert(I->second).second)
continue;
- Opts.push_back(
- std::pair<const char *, Option *>(I->getKey().data(), I->second));
+ std::pair<const char*, Option*> KVP(I->first.c_str(), I->second);
+ Opts.push_back(KVP);
}
// Sort the options list alphabetically.
- array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare);
+ OptNameCompare<std::pair<const char*, Option*> > ONC;
+ std::sort(Opts.begin(), Opts.end(), ONC);
}
namespace {
class HelpPrinter {
+private:
+ /// Force the allocation of storage space with suitable alignment
+ /// for this class because we use a static instance of it as
+ /// designated external storage for version option parsing (see below).
+ uint64_t B[4];
+
protected:
const bool ShowHidden;
- typedef SmallVector<std::pair<const char *, Option *>, 128>
+ typedef std::vector<std::pair<const char *, Option *> >
StrOptionPairVector;
+
// Print the options. Opts is assumed to be alphabetically sorted.
virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
for (size_t i = 0, e = Opts.size(); i != e; ++i)
@@ -1487,7 +1943,11 @@
}
public:
- explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
+ explicit HelpPrinter(bool showHidden = false)
+ : ShowHidden(showHidden) {
+ (void) std::memset(B, 0, sizeof(B));
+ }
+
virtual ~HelpPrinter() {}
// Invoke the printer.
@@ -1495,6 +1955,12 @@
if (!Value)
return;
+ // Get all the options,
+ std::vector<Option *> PositionalOpts;
+ std::vector<Option *> SinkOpts;
+ llvm::cl::StdStringMap OptionsMap;
+ CommandLineParser::GetOptionInfo(PositionalOpts, SinkOpts, OptionsMap);
+
StrOptionPairVector Opts;
sortOpts(GlobalParser->OptionsMap, Opts, ShowHidden);
@@ -1503,6 +1969,12 @@
outs() << "USAGE: " << GlobalParser->ProgramName << " [options]";
+ // Print out the positional options.
+ Option *CAOpt = nullptr; // The cl::ConsumeAfter option, if it exists...
+ if (!PositionalOpts.empty() &&
+ PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter)
+ CAOpt = PositionalOpts[0];
+
for (auto Opt : GlobalParser->PositionalOpts) {
if (Opt->hasArgStr())
outs() << " --" << Opt->ArgStr;
@@ -1512,6 +1984,8 @@
// Print the consume after option info if it exists...
if (GlobalParser->ConsumeAfterOpt)
outs() << " " << GlobalParser->ConsumeAfterOpt->HelpStr;
+ else if (CAOpt)
+ outs() << " " << CAOpt->HelpStr;
outs() << "\n\n";
@@ -1531,6 +2005,11 @@
// Halt the program since help information was printed
exit(0);
}
+
+ void operator=(const HelpPrinter &RHS) {
+ HelpPrinter::operator=(true);
+ }
+
};
class CategorizedHelpPrinter : public HelpPrinter {
@@ -1619,80 +2098,148 @@
}
};
-// This wraps the Uncategorizing and Categorizing printers and decides
-// at run time which should be invoked.
-class HelpPrinterWrapper {
+// Declare the four HelpPrinter instances that are used to print out help, or
+// help-hidden as an uncategorized list or in categories.
+static HelpPrinter UncategorizedNormalPrinter(false);
+static HelpPrinter UncategorizedHiddenPrinter(true);
+static CategorizedHelpPrinter CategorizedNormalPrinter(false);
+static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
+
+// This wraps the Uncategorizing and Categorizing Normal printers
+// and decides at run time which should be invoked.
+// Except it doesn't work the way you think it does.
+class NormalHelpPrinterWrapper {
private:
HelpPrinter &UncategorizedPrinter;
CategorizedHelpPrinter &CategorizedPrinter;
public:
- explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
- CategorizedHelpPrinter &CategorizedPrinter)
- : UncategorizedPrinter(UncategorizedPrinter),
- CategorizedPrinter(CategorizedPrinter) {}
+ explicit NormalHelpPrinterWrapper(HelpPrinter &UNP =
+ UncategorizedNormalPrinter,
+ CategorizedHelpPrinter &CNP =
+ CategorizedNormalPrinter)
+ : UncategorizedPrinter(UNP), CategorizedPrinter(CNP) { }
// Invoke the printer.
void operator=(bool Value);
+ void operator=(const NormalHelpPrinterWrapper &RHS);
+};
+
+class HiddenHelpPrinterWrapper {
+private:
+ HelpPrinter &UncategorizedPrinter;
+ CategorizedHelpPrinter &CategorizedPrinter;
+
+public:
+ explicit HiddenHelpPrinterWrapper(HelpPrinter &UHP =
+ UncategorizedHiddenPrinter,
+ CategorizedHelpPrinter &CHP =
+ CategorizedHiddenPrinter)
+ : UncategorizedPrinter(UHP), CategorizedPrinter(CHP) { }
+
+ // Invoke the printer.
+ void operator=(bool Value);
+ void operator=(const HiddenHelpPrinterWrapper &RHS);
};
} // End anonymous namespace
+#if 0
// Declare the four HelpPrinter instances that are used to print out help, or
// help-hidden as an uncategorized list or in categories.
static HelpPrinter UncategorizedNormalPrinter(false);
static HelpPrinter UncategorizedHiddenPrinter(true);
static CategorizedHelpPrinter CategorizedNormalPrinter(false);
static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
+#endif
// Declare HelpPrinter wrappers that will decide whether or not to invoke
// a categorizing help printer
-static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
- CategorizedNormalPrinter);
-static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
- CategorizedHiddenPrinter);
+static NormalHelpPrinterWrapper
+WrappedNormalPrinter(UncategorizedNormalPrinter, CategorizedNormalPrinter);
+
+static HiddenHelpPrinterWrapper
+WrappedHiddenPrinter(UncategorizedHiddenPrinter, CategorizedHiddenPrinter);
// Define a category for generic options that all tools should have.
-static cl::OptionCategory GenericCategory("Generic Options");
+static cl::OptionCategory
+GenericCategory("Generic Options");
// Define uncategorized help printers.
// -help-list is hidden by default because if Option categories are being used
// then -help behaves the same as -help-list.
-static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
- "help-list",
+// static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
+static cl::opt<HelpPrinter, false, parser<bool>>
+HLOp("help-list",
cl::desc("Display list of available options (-help-list-hidden for more)"),
- cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
+ cl::location(UncategorizedNormalPrinter), cl::Hidden,
+ cl::ValueDisallowed,
cl::cat(GenericCategory));
-static cl::opt<HelpPrinter, true, parser<bool>>
- HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
- cl::location(UncategorizedHiddenPrinter), cl::Hidden,
- cl::ValueDisallowed, cl::cat(GenericCategory));
+// static cl::opt<HelpPrinter, true, parser<bool>>
+static cl::opt<HelpPrinter, false, parser<bool>>
+HLHOp("help-list-hidden",
+ cl::desc("Display list of all available options"),
+ cl::location(UncategorizedHiddenPrinter),
+ cl::Hidden,
+ cl::ValueDisallowed,
+ cl::cat(GenericCategory));
// Define uncategorized/categorized help printers. These printers change their
// behaviour at runtime depending on whether one or more Option categories have
// been declared.
-static cl::opt<HelpPrinterWrapper, true, parser<bool>>
- HOp("help", cl::desc("Display available options (-help-hidden for more)"),
- cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
+// static cl::opt<HelpPrinterWrapper, true, parser<bool>>
+static cl::opt<NormalHelpPrinterWrapper, false, parser<bool>>
+HOp("help",
+ cl::desc("Display available options (-help-hidden for more)"),
+ cl::location(WrappedNormalPrinter),
+ cl::ValueDisallowed,
cl::cat(GenericCategory));
-static cl::opt<HelpPrinterWrapper, true, parser<bool>>
- HHOp("help-hidden", cl::desc("Display all available options"),
- cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
+// static cl::opt<HelpPrinterWrapper, true, parser<bool>>
+static cl::opt<HiddenHelpPrinterWrapper, false, parser<bool>>
+HHOp("help-hidden",
+ cl::desc("Display all available options"),
+ cl::location(WrappedHiddenPrinter), cl::Hidden,
+ cl::ValueDisallowed,
cl::cat(GenericCategory));
-static cl::opt<bool> PrintOptions(
- "print-options",
+static cl::opt<bool>
+PrintOptions("print-options",
cl::desc("Print non-default options after command line parsing"),
- cl::Hidden, cl::init(false), cl::cat(GenericCategory));
+ cl::Hidden,
+ cl::init(false),
+ cl::cat(GenericCategory));
+
+static cl::opt<bool>
+PrintAllOptions("print-all-options",
+ cl::desc("Print all option values after command line parsing"),
+ cl::Hidden,
+ cl::init(false),
+ cl::cat(GenericCategory));
-static cl::opt<bool> PrintAllOptions(
- "print-all-options",
- cl::desc("Print all option values after command line parsing"), cl::Hidden,
- cl::init(false), cl::cat(GenericCategory));
+void NormalHelpPrinterWrapper::operator=(bool Value) {
+ if (!Value)
+ return;
-void HelpPrinterWrapper::operator=(bool Value) {
+ // Decide which printer to invoke. If more than one option category is
+ // registered then it is useful to show the categorized help instead of
+ // uncategorized help.
+ if (GlobalParser->RegisteredOptionCategories.size() > 1) {
+ // unhide -help-list option so user can have uncategorized output if they
+ // want it.
+ HLOp.setHiddenFlag(NotHidden);
+
+ CategorizedPrinter = true; // Invoke categorized printer
+ } else
+ UncategorizedPrinter = true; // Invoke uncategorized printer
+}
+
+void NormalHelpPrinterWrapper::operator=(const NormalHelpPrinterWrapper &RHS) {
+ NormalHelpPrinterWrapper::operator=(true);
+}
+
+void HiddenHelpPrinterWrapper::operator=(bool Value) {
if (!Value)
return;
@@ -1709,14 +2256,20 @@
UncategorizedPrinter = true; // Invoke uncategorized printer
}
+void HiddenHelpPrinterWrapper::operator=(const HiddenHelpPrinterWrapper &RHS) {
+ HiddenHelpPrinterWrapper::operator=(true);
+}
+
// Print the value of each option.
-void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
+void cl::PrintOptionValues() { GlobalParser->PrintOptionValues(); }
-void CommandLineParser::printOptionValues() {
+void CommandLineParser::PrintOptionValues() {
if (!PrintOptions && !PrintAllOptions)
return;
- SmallVector<std::pair<const char *, Option *>, 128> Opts;
+ GetOptionInfo(PositionalOpts, SinkOpts, OptionsMap);
+
+ std::vector<std::pair<const char *, Option *> > Opts;
sortOpts(OptionsMap, Opts, /*ShowHidden*/ true);
// Compute the maximum argument length...
@@ -1732,35 +2285,51 @@
static std::vector<void (*)()> *ExtraVersionPrinters = nullptr;
-namespace {
+namespace llvm {
+ namespace cl {
class VersionPrinter {
+ private:
+ /// Force the allocation of storage space with suitable alignment
+ /// for this class because we use a static instance of it as
+ /// designated external storage for version option parsing (see below).
+ uint64_t B[4];
+
public:
+ VersionPrinter() {
+ (void) std::memset(B, 0, sizeof(B));
+ }
+
+ static VersionPrinter &instance();
+
void print() {
raw_ostream &OS = outs();
- OS << "LLVM (http://llvm.org/):\n"
+ std::cout << "LLVM (http://llvm.org/):\n"
<< " " << PACKAGE_NAME << " version " << PACKAGE_VERSION;
#ifdef LLVM_VERSION_INFO
- OS << " " << LLVM_VERSION_INFO;
+ std::cout < " " << LLVM_VERSION_INFO;
#endif
- OS << "\n ";
+ std::cout << "\n ";
#ifndef __OPTIMIZE__
- OS << "DEBUG build";
+ std::cout << "DEBUG build";
#else
- OS << "Optimized build";
+ std::cout << "Optimized build";
#endif
#ifndef NDEBUG
- OS << " with assertions";
+ std::cout << " with assertions";
#endif
std::string CPU = sys::getHostCPUName();
if (CPU == "generic")
CPU = "(unknown)";
- OS << ".\n"
+
+ std::cout << ".\n"
+
#if (ENABLE_TIMESTAMPS == 1)
<< " Built " << __DATE__ << " (" << __TIME__ << ").\n"
#endif
<< " Default target: " << sys::getDefaultTargetTriple() << '\n'
<< " Host CPU: " << CPU << '\n';
}
+
void operator=(bool OptionWasSpecified) {
if (!OptionWasSpecified)
return;
@@ -1769,33 +2338,42 @@
(*OverrideVersionPrinter)();
exit(0);
}
+
print();
- // Iterate over any registered extra printers and call them to add further
- // information.
+ // Iterate over any registered extra printers and call them
+ // to add further information.
if (ExtraVersionPrinters != nullptr) {
- outs() << '\n';
- for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(),
- E = ExtraVersionPrinters->end();
+ std::cout << std::endl;
+ for (std::vector<void (*)()>::iterator I =
+ ExtraVersionPrinters->begin(), E = ExtraVersionPrinters->end();
I != E; ++I)
(*I)();
}
exit(0);
}
+
+ void operator=(const VersionPrinter &RHS) {
+ VersionPrinter::operator=(true);
+ }
};
-} // End anonymous namespace
+ } // end namespace cl
+} // End namespace llvm
// Define the --version option that prints out the LLVM version for the tool
-static VersionPrinter VersionPrinterInstance;
+static llvm::cl::VersionPrinter VersionPrinterInstance;
-static cl::opt<VersionPrinter, true, parser<bool>>
- VersOp("version", cl::desc("Display the version of this program"),
- cl::location(VersionPrinterInstance), cl::ValueDisallowed,
- cl::cat(GenericCategory));
+static
+cl::opt<llvm::cl::VersionPrinter, false, parser<bool> >
+VersOp("version", cl::desc("Display the version of this program"),
+ cl::location(VersionPrinterInstance),
+ cl::ValueRequired,
+ cl::cat(GenericCategory));
// Utility function for printing the help message.
void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
+
// This looks weird, but it actually prints the help message. The Printers are
// types of HelpPrinter and the help gets printed when its operator= is
// invoked. That's because the "normal" usages of the help printer is to be
@@ -1814,7 +2392,9 @@
}
/// Utility function for printing version number.
-void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
+void cl::PrintVersionMessage() {
+ VersionPrinterInstance.print();
+}
void cl::SetVersionPrinter(void (*func)()) { OverrideVersionPrinter = func; }
@@ -1826,7 +2406,16 @@
}
StringMap<Option *> &cl::getRegisteredOptions() {
- return GlobalParser->OptionsMap;
+
+ GlobalParser->ReturnOptionsMap.clear();
+ for (llvm::cl::StdStringMap::const_iterator I =
+ GlobalParser->OptionsMap.begin(), E = GlobalParser->OptionsMap.end();
+ I != E; ++I) {
+ GlobalParser->ReturnOptionsMap.insert(std::make_pair((*I).first.c_str(),
+ (*I).second));
+ }
+
+ return GlobalParser->ReturnOptionsMap;
}
void cl::HideUnrelatedOptions(cl::OptionCategory &Category) {
@@ -1852,3 +2441,4 @@
const char *Overview) {
llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
}
+
###
--- lib/Support/Options.cpp 2014-10-15 14:54:35.000000000 -0700
+++ lib/Support/Options.cpp 2016-05-14 12:34:43.808666693 -0700
@@ -24,8 +24,9 @@
void OptionRegistry::addOption(void *Key, cl::Option *O) {
assert(Options.find(Key) == Options.end() &&
- "Argument with this key already registerd");
+ "Argument with this key already registered");
Options.insert(std::make_pair(Key, O));
+ O->addOccurrence();
}
static ManagedStatic<OptionRegistry> OR;
###
--- include/llvm/Support/RandomNumberGenerator.h 2015-06-23 01:49:53.000000000 -0800
+++ include/llvm/Support/RandomNumberGenerator.h 2016-07-05 06:13:50.168003475 -0800
@@ -32,7 +32,11 @@
class RandomNumberGenerator {
public:
/// Returns a random number in the range [0, Max).
- uint_fast64_t operator()();
+ uint64_t operator()();
+
+ /// Workaround for static global initialization order in shared
+ /// libraries in Solaris. Solaris ld does not support init_priority.
+ static bool Initialize();
private:
/// Seeds and salts the underlying RNG engine.
###
--- lib/Support/RandomNumberGenerator.cpp 2015-03-23 10:19:41.000000000 -0800
+++ lib/Support/RandomNumberGenerator.cpp 2016-07-05 18:49:45.063365340 -0800
@@ -20,19 +20,45 @@
using namespace llvm;
+#include <chrono>
+
#define DEBUG_TYPE "rng"
+
// Tracking BUG: 19665
// http://llvm.org/bugs/show_bug.cgi?id=19665
//
-// Do not change to cl::opt<uint64_t> since this silently breaks argument parsing.
-static cl::opt<unsigned long long>
-Seed("rng-seed", cl::value_desc("seed"),
- cl::desc("Seed for the random number generator"), cl::init(0));
+// Do not change to cl::opt<uint64_t> since this silently breaks
+// argument parsing.
+static llvm::cl::opt<unsigned long long>
+Seed(cl::Prefix, "rng-seed",
+ cl::desc("Seed for the random number generator"),
+ cl::value_desc("seed"),
+ cl::NotHidden,
+ cl::Optional,
+ cl::init(0ULL),
+ cl::ValueRequired);
+
+static bool InitFirst = false;
+
+bool __attribute__((noinline))
+RandomNumberGenerator::Initialize() {
+ auto Now = std::chrono::system_clock::now();
+ Seed.setValue(static_cast<unsigned long long>(
+ std::chrono::system_clock::to_time_t(Now)));
+ return true;
+}
+
+RandomNumberGenerator::RandomNumberGenerator(StringRef Salt)
+ : Generator() {
+ if (!InitFirst) {
+ InitFirst = RandomNumberGenerator::Initialize();
+ if (!InitFirst)
+ llvm_unreachable("Static initialization failed!");
+ }
-RandomNumberGenerator::RandomNumberGenerator(StringRef Salt) {
DEBUG(
- if (Seed == 0)
+ if (Seed.getValue() == 0ULL)
dbgs() << "Warning! Using unseeded random number generator.\n"
);
@@ -42,9 +68,10 @@
// are using a 64-bit RNG. This isn't a problem since the Mersenne
// twister constructor copies these correctly into its initial state.
std::vector<uint32_t> Data;
- Data.reserve(2 + Salt.size());
- Data.push_back(Seed);
- Data.push_back(Seed >> 32);
+ Data.resize(2 + Salt.size());
+ unsigned long long V = Seed.getValue();
+ Data.push_back(V);
+ Data.push_back(V >> 32);
std::copy(Salt.begin(), Salt.end(), Data.end());
@@ -52,6 +79,7 @@
Generator.seed(SeedSeq);
}
-uint_fast64_t RandomNumberGenerator::operator()() {
- return Generator();
+uint64_t RandomNumberGenerator::operator()() {
+ return static_cast<uint64_t>(Generator());
}
+
###
--- lib/Support/Unix/Path.inc 2015-11-02 09:57:24.000000000 -0500
+++ lib/Support/Unix/Path.inc 2016-05-22 16:56:44.390780570 -0400
@@ -469,7 +469,7 @@
std::error_code detail::directory_iterator_construct(detail::DirIterState &it,
StringRef path){
- SmallString<128> path_null(path);
+ SmallString<PATH_MAX> path_null(path);
DIR *directory = ::opendir(path_null.c_str());
if (!directory)
return std::error_code(errno, std::generic_category());
@@ -484,8 +484,10 @@
std::error_code detail::directory_iterator_destruct(detail::DirIterState &it) {
if (it.IterationHandle)
::closedir(reinterpret_cast<DIR *>(it.IterationHandle));
+
it.IterationHandle = 0;
- it.CurrentEntry = directory_entry();
+ directory_entry de;
+ it.CurrentEntry = de;
return std::error_code();
}
###
--- include/llvm/Support/FileSystem.h 2015-11-05 20:45:30.000000000 -0500
+++ include/llvm/Support/FileSystem.h 2016-05-22 20:58:26.603743052 -0400
@@ -695,15 +695,43 @@
mutable file_status Status;
public:
- explicit directory_entry(const Twine &path, file_status st = file_status())
- : Path(path.str())
- , Status(st) {}
+ explicit directory_entry(const Twine &path, file_status ST = file_status())
+ : Path(path.str()), Status(ST) { }
- directory_entry() {}
+ directory_entry() : Path(""), Status(file_status()) { }
- void assign(const Twine &path, file_status st = file_status()) {
+ directory_entry(const directory_entry &RHS)
+ : Path(RHS.Path), Status(RHS.Status) { }
+
+ directory_entry(directory_entry &&RHS)
+ : Path(""), Status(file_status()) {
+ Path = std::move(RHS.Path);
+ Status = std::move(RHS.Status);
+ }
+
+ ~directory_entry() { }
+
+ directory_entry &operator=(const directory_entry &rhs) {
+ if (this != &rhs) {
+ Path = rhs.Path;
+ Status = rhs.Status;
+ }
+
+ return *this;
+ }
+
+ const directory_entry &operator=(directory_entry &&rhs) {
+ if (this != &rhs) {
+ Path = std::move(rhs.Path);
+ Status = std::move(rhs.Status);
+ }
+
+ return *this;
+ }
+
+ void assign(const Twine &path, file_status ST = file_status()) {
Path = path.str();
- Status = st;
+ Status = ST;
}
void replace_filename(const Twine &filename, file_status st = file_status());
###
--- include/llvm/Support/PluginLoader.h 2015-06-23 05:49:53.000000000 -0400
+++ include/llvm/Support/PluginLoader.h 2016-05-08 23:19:20.527430631 -0400
@@ -22,6 +22,9 @@
namespace llvm {
struct PluginLoader {
void operator=(const std::string &Filename);
+ bool operator==(const std::string &Filename) const;
+ bool operator!=(const std::string &Filename) const;
+
static unsigned getNumPlugins();
static std::string& getPlugin(unsigned num);
};
###
--- include/llvm/Support/Process.h 2015-06-23 05:49:53.000000000 -0400
+++ include/llvm/Support/Process.h 2016-05-08 23:19:20.527430631 -0400
@@ -88,6 +88,12 @@
ArrayRef<const char *> ArgsFromMain,
SpecificBumpPtrAllocator<char> &ArgAllocator);
+ /// Overload the above for a std::vector, and without the
+ /// useless SpecificBumpPtrAllocator argument.
+ static std::error_code
+ GetArgumentVector(std::vector<const char *> &ArgsOut,
+ ArrayRef<const char *> ArgsIn);
+
// This functions ensures that the standard file descriptors (input, output,
// and error) are properly mapped to a file descriptor before we use any of
// them. This should only be called by standalone programs, library
###
--- include/llvm/Support/ThreadLocal.h 2015-06-23 02:49:53.000000000 -0700
+++ include/llvm/Support/ThreadLocal.h 2016-05-24 18:32:55.335317270 -0700
@@ -28,10 +28,8 @@
///
/// This is embedded in the class and we avoid malloc'ing/free'ing it,
/// to make this class more safe for use along with CrashRecoveryContext.
- union {
- char data[sizeof(ThreadLocalDataTy)];
- ThreadLocalDataTy align_data;
- };
+ uint64_t data[2];
+
public:
ThreadLocalImpl();
virtual ~ThreadLocalImpl();
@@ -42,7 +40,7 @@
/// ThreadLocal - A class used to abstract thread-local storage. It holds,
/// for each thread, a pointer a single object of type T.
- template<class T>
+ template<typename T>
class ThreadLocal : public ThreadLocalImpl {
public:
ThreadLocal() : ThreadLocalImpl() { }
###
--- lib/Support/ThreadLocal.cpp 2014-12-14 17:19:53.000000000 -0800
+++ lib/Support/ThreadLocal.cpp 2016-05-24 18:36:15.908033311 -0700
@@ -15,6 +15,8 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ThreadLocal.h"
+#include <cstring>
+
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
//=== independent code.
@@ -24,17 +26,24 @@
// Define all methods as no-ops if threading is explicitly disabled
namespace llvm {
using namespace sys;
-ThreadLocalImpl::ThreadLocalImpl() : data() { }
+
+ThreadLocalImpl::ThreadLocalImpl() {
+ (void) std::memset(data, 0, sizeof(data));
+}
+
ThreadLocalImpl::~ThreadLocalImpl() { }
+
void ThreadLocalImpl::setInstance(const void* d) {
static_assert(sizeof(d) <= sizeof(data), "size too big");
void **pd = reinterpret_cast<void**>(&data);
*pd = const_cast<void*>(d);
}
+
void *ThreadLocalImpl::getInstance() {
void **pd = reinterpret_cast<void**>(&data);
return *pd;
}
+
void ThreadLocalImpl::removeInstance() {
setInstance(nullptr);
}
###
--- include/llvm/Support/BranchProbability.h 2015-12-22 09:56:14.000000000 -0900
+++ include/llvm/Support/BranchProbability.h 2016-07-07 09:50:50.352228870 -0800
@@ -29,6 +29,7 @@
// denominator is always a constant value (here we use 1<<31 for maximum
// precision).
class BranchProbability {
+private:
// Numerator
uint32_t N;
@@ -38,12 +39,32 @@
// Construct a BranchProbability with only numerator assuming the denominator
// is 1<<31. For internal use only.
- explicit BranchProbability(uint32_t n) : N(n) {}
+ explicit BranchProbability(uint32_t n) : N(n) { }
public:
- BranchProbability() : N(UnknownN) {}
+ BranchProbability() : N(UnknownN) { }
BranchProbability(uint32_t Numerator, uint32_t Denominator);
+ // If we are using this class in STL containers (such as std::vector),
+ // and we are indeed doing that (see CodeGen/MachineBasicBlock.cpp),
+ // then this class must satisfiy MoveInsertable, CopyInsertable and
+ // DefaultInsertable.
+ BranchProbability(const BranchProbability &RHS) : N(RHS.N) { }
+ BranchProbability(BranchProbability &&RHS) : N(std::move(RHS.N)) { }
+ BranchProbability &operator=(const BranchProbability &RHS) {
+ if (this != &RHS)
+ N = RHS.N;
+ return *this;
+ }
+
+ const BranchProbability &operator=(BranchProbability &&RHS) {
+ if (this != &RHS)
+ N = std::move(RHS.N);
+ return *this;
+ }
+
+ ~BranchProbability() { }
+
bool isZero() const { return N == 0; }
bool isUnknown() const { return N == UnknownN; }
###.
--- lib/Support/Host.cpp 2015-12-15 08:35:29.000000000 -0500
+++ lib/Support/Host.cpp 2016-05-08 23:19:20.536430850 -0400
@@ -39,6 +39,11 @@
#include <mach/machine.h>
#endif
+#if defined(__sun__)
+#include <cstring>
+#include <kstat.h>
+#endif
+
#define DEBUG_TYPE "host-detection"
//===----------------------------------------------------------------------===//
@@ -733,6 +738,42 @@
return "generic";
}
+#elif defined(__sun__) && defined(__sparc__)
+StringRef sys::getHostCPUName() {
+ kstat_ctl_t *KC = 0;
+ kstat_t *KSP = 0;
+ kstat_named_t *KNP = 0;
+ static char Buffer[256];
+ static bool Init = false;
+ const char *Value;
+
+ if (!Init) {
+ KC = kstat_open();
+ if (KC) {
+ KSP = kstat_lookup(KC, "cpu_info", -1, "cpu_info0");
+ kstat_read(KC, KSP, NULL);
+ KNP = reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "brand"));
+ Value = (const char *) KNP->value.str.addr.ptr;
+ (void) std::sprintf(Buffer, "%s (", Value);
+
+ KNP =
+ reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "cpu_type"));
+ Value = (const char*) KNP->value.c;
+ (void) std::strcat(Buffer, Value);
+ (void) std::strcat(Buffer, ") ");
+
+ KNP =
+ reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP,
+ "implementation"));
+ Value = (const char*) KNP->value.str.addr.ptr;
+ (void) std::strcat(Buffer, Value);
+ Init = true;
+ kstat_close(KC);
+ }
+ }
+
+ return Buffer;
+}
#else
StringRef sys::getHostCPUName() {
return "generic";
--- lib/Support/MemoryBuffer.cpp 2015-10-14 21:27:19.000000000 -0400
+++ lib/Support/MemoryBuffer.cpp 2016-05-08 23:19:20.536430850 -0400
@@ -32,6 +32,9 @@
#else
#include <io.h>
#endif
+
+#include <climits>
+
using namespace llvm;
//===----------------------------------------------------------------------===//
@@ -70,7 +73,7 @@
}
void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
- SmallString<256> NameBuf;
+ SmallString<PATH_MAX> NameBuf;
StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));
@@ -132,7 +135,7 @@
// that MemoryBuffer and data are aligned so PointerIntPair works with them.
// TODO: Is 16-byte alignment enough? We copy small object files with large
// alignment expectations into this buffer.
- SmallString<256> NameBuf;
+ SmallString<PATH_MAX> NameBuf;
StringRef NameRef = BufferName.toStringRef(NameBuf);
size_t AlignedStringLen =
RoundUpToAlignment(sizeof(MemoryBufferMem) + NameRef.size() + 1, 16);
@@ -164,7 +167,7 @@
ErrorOr<std::unique_ptr<MemoryBuffer>>
MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,
bool RequiresNullTerminator) {
- SmallString<256> NameBuf;
+ SmallString<PATH_MAX> NameBuf;
StringRef NameRef = Filename.toStringRef(NameBuf);
if (NameRef == "-")
--- lib/Support/PluginLoader.cpp 2012-12-03 11:50:05.000000000 -0500
+++ lib/Support/PluginLoader.cpp 2016-05-08 23:19:20.536430850 -0400
@@ -34,6 +34,21 @@
}
}
+bool PluginLoader::operator==(const std::string &Filename) const {
+ sys::SmartScopedLock<true> Lock(*PluginsLock);
+ for (std::vector<std::string>::const_iterator I = Plugins->begin(),
+ E = Plugins->end(); I != E; ++I) {
+ if (*I == Filename)
+ return true;
+ }
+
+ return false;
+}
+
+bool PluginLoader::operator!=(const std::string &Filename) const {
+ return !this->operator==(Filename);
+}
+
unsigned PluginLoader::getNumPlugins() {
sys::SmartScopedLock<true> Lock(*PluginsLock);
return Plugins.isConstructed() ? Plugins->size() : 0;
###
--- lib/Support/SmallVector.cpp 2015-06-09 02:47:46.000000000 -0700
+++ lib/Support/SmallVector.cpp 2016-05-23 11:37:44.177294041 -0700
@@ -11,9 +11,13 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
+#include <stdlib.h>
+
/// grow_pod - This is an implementation of the grow() method which only works
/// on POD-like datatypes and is out of line to reduce code duplication.
void SmallVectorBase::grow_pod(void *FirstEl, size_t MinSizeInBytes,
@@ -23,15 +27,41 @@
if (NewCapacityInBytes < MinSizeInBytes)
NewCapacityInBytes = MinSizeInBytes;
+ NewCapacityInBytes =
+ llvm::RoundUpToAlignment(NewCapacityInBytes, llvm::alignOf<uint64_t>());
+
void *NewElts;
+ size_t Alignment = llvm::alignOf<uint64_t>();
if (BeginX == FirstEl) {
- NewElts = malloc(NewCapacityInBytes);
+#if defined(_MSC_VER)
+ NewElts = _aligned_malloc(Alignment, NewCapacityInBytes);
+ assert(NewElts && "_aligned_malloc failed!");
+#else
+ int R = posix_memalign(&NewElts, Alignment, NewCapacityInBytes);
+ assert((R == 0) && "posix_memalign failed!");
+#endif
+
+ assert(NewElts && "Invalid pointer after aligned allocation!");
+ (void) std::memset(NewElts, 0, NewCapacityInBytes);
// Copy the elements over. No need to run dtors on PODs.
- memcpy(NewElts, this->BeginX, CurSizeBytes);
+ (void) std::memcpy(NewElts, this->BeginX, CurSizeBytes);
} else {
// If this wasn't grown from the inline copy, grow the allocated space.
- NewElts = realloc(this->BeginX, NewCapacityInBytes);
+#if defined(_MSC_VER)
+ NewElts = _aligned_malloc(Alignment, NewCapacityInBytes);
+ assert(NewElts && "_aligned_malloc failed!");
+#else
+ int R = posix_memalign(&NewElts, Alignment, NewCapacityInBytes);
+ assert((R == 0) && "posix_memalign failed!");
+#endif
+
+ assert(NewElts && "Invalid pointer after aligned allocation!");
+ (void) std::memset(NewElts, 0, NewCapacityInBytes);
+
+ // Copy the elements over. No need to run dtors on PODs.
+ (void) std::memcpy(NewElts, this->BeginX, CurSizeBytes);
+ std::free(this->BeginX);
}
assert(NewElts && "Out of memory");
@@ -39,3 +69,4 @@
this->BeginX = NewElts;
this->CapacityX = (char*)this->BeginX + NewCapacityInBytes;
}
+
###
--- lib/Support/Unix/Process.inc 2015-12-11 17:52:32.000000000 -0500
+++ lib/Support/Unix/Process.inc 2016-05-08 23:19:20.537430874 -0400
@@ -188,6 +188,14 @@
return std::error_code();
}
+std::error_code
+Process::GetArgumentVector(std::vector<const char *> &ArgsOut,
+ ArrayRef<const char *> ArgsIn) {
+ ArgsOut.insert(ArgsOut.end(), ArgsIn.begin(), ArgsIn.end());
+
+ return std::error_code();
+}
+
namespace {
class FDCloser {
public:
--- lib/Support/Unix/Program.inc 2016-01-05 14:56:12.000000000 -0500
+++ lib/Support/Unix/Program.inc 2016-05-08 23:19:20.537430874 -0400
@@ -40,9 +40,6 @@
#include <unistd.h>
#endif
#ifdef HAVE_POSIX_SPAWN
-#ifdef __sun__
-#define _RESTRICT_KYWD
-#endif
#include <spawn.h>
#if defined(__APPLE__)
###
--- include/llvm/LinkAllPasses.h 2016-01-13 10:37:51.000000000 -0900
+++ include/llvm/LinkAllPasses.h 2016-07-06 07:55:00.479529980 -0800
@@ -43,18 +43,24 @@
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
#include "llvm/Transforms/Vectorize.h"
#include "llvm/Support/Valgrind.h"
+
#include <cstdlib>
-namespace {
- struct ForcePassLinking {
+namespace llvm {
+ class ForcePassLinking {
+ public:
ForcePassLinking() {
// We must reference the passes in such a way that compilers will not
// delete it all as dead code, even with whole program optimization,
// yet is effectively a NO-OP. As the compiler isn't smart enough
// to know that getenv() never returns -1, this will do the job.
+ // Except for the fact that your theory doesn't work.
if (std::getenv("bar") != (char*) -1)
return;
+ // Hi, GCC. Please don't throw this function away.
+ asm("");
+
(void) llvm::createAAEvalPass();
(void) llvm::createAggressiveDCEPass();
(void) llvm::createBitTrackingDCEPass();
@@ -160,11 +166,13 @@
(void) llvm::createPostOrderFunctionAttrsPass();
(void) llvm::createReversePostOrderFunctionAttrsPass();
(void) llvm::createMergeFunctionsPass();
- std::string buf;
- llvm::raw_string_ostream os(buf);
- (void) llvm::createPrintModulePass(os);
- (void) llvm::createPrintFunctionPass(os);
- (void) llvm::createPrintBasicBlockPass(os);
+
+ std::string S;
+ llvm::raw_string_ostream RSO(S);
+ (void) llvm::createPrintModulePass(RSO);
+ (void) llvm::createPrintFunctionPass(RSO);
+ (void) llvm::createPrintBasicBlockPass(RSO);
+
(void) llvm::createModuleDebugInfoPrinterPass();
(void) llvm::createPartialInliningPass();
(void) llvm::createLintPass();
@@ -186,17 +194,39 @@
(void) llvm::createFloat2IntPass();
(void) llvm::createEliminateAvailableExternallyPass();
- (void)new llvm::IntervalPartition();
- (void)new llvm::ScalarEvolutionWrapperPass();
- llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage)->viewCFGOnly();
+ llvm::IntervalPartition *LIP = new llvm::IntervalPartition();
+ (void) LIP;
+
+ llvm::ScalarEvolutionWrapperPass *LSE =
+ new llvm::ScalarEvolutionWrapperPass();
+ (void) LSE;
+
+ llvm::Function *F =
+ llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage);
+ (void) F;
+ F->viewCFGOnly();
+
llvm::RGPassManager RGM;
llvm::AliasAnalysis AA;
llvm::AliasSetTracker X(AA);
X.add(nullptr, 0, llvm::AAMDNodes()); // for -print-alias-sets
- (void) llvm::AreStatisticsEnabled();
- (void) llvm::sys::RunningOnValgrind();
+
+ bool B1 = llvm::AreStatisticsEnabled();
+ (void) B1;
+ bool B2 = llvm::sys::RunningOnValgrind();
+ (void) B1;
}
- } ForcePassLinking; // Force link by creating a global definition.
+
+ ~ForcePassLinking() { }
+
+ private:
+ /// Initialization of this is done in lib/CodeGen/Passes.cpp
+ /// because of initialization ordering problems with global
+ /// static variables. The design of this static initialization
+ /// dependency chain is completely broken.
+ static ForcePassLinking *FPL;
+ };
}
#endif
+