# 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

@@ -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.

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