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