# 21851513 severe memory corruption in the LLVM command-line parsing module

# 21870103 TableGen makes incorrect assumptions about anonymous namespace instantiation

# 21870087 naming convention for the InputFile key is inconsistent across LLVM utilities

# 21870099 128 bytes for a filesystem path is definitely not enough

# clang makes incorrect assumptions about anonymous namespace instantiation order

# For upstream - maybe.

--- include/llvm/Support/ThreadLocal.h	2014-12-14 17:04:45.000000000 -0800

+++ include/llvm/Support/ThreadLocal.h	2015-09-16 14:08:58.000000000 -0700

@@ -21,24 +21,22 @@

 namespace llvm {

   namespace sys {

     // ThreadLocalImpl - Common base class of all ThreadLocal instantiations.

     // YOU SHOULD NEVER USE THIS DIRECTLY.

     class ThreadLocalImpl {

       typedef uint64_t ThreadLocalDataTy;

       /// \brief Platform-specific thread local data.

       ///

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

       void setInstance(const void* d);

       void *getInstance();

       void removeInstance();

     };

     /// ThreadLocal - A class used to abstract thread-local storage.  It holds,

     /// for each thread, a pointer a single object of type T.

--- lib/Support/MemoryBuffer.cpp	2014-12-12 14:27:53.000000000 -0800

+++ lib/Support/MemoryBuffer.cpp	2015-09-19 14:20:06.472430028 -0700

@@ -21,25 +21,29 @@

 #include "llvm/Support/Path.h"

 #include "llvm/Support/Process.h"

 #include "llvm/Support/Program.h"

 #include <cassert>

 #include <cerrno>

 #include <cstdio>

 #include <cstring>

 #include <new>

 #include <sys/types.h>

 #include <system_error>

+

 #if !defined(_MSC_VER) && !defined(__MINGW32__)

 #include <unistd.h>

 #else

 #include <io.h>

 #endif

+

+#include <climits>

+

 using namespace llvm;

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

 // MemoryBuffer implementation itself.

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

 MemoryBuffer::~MemoryBuffer() { }

 /// init - Initialize this MemoryBuffer as a reference to externally allocated

 /// memory, memory that we know is already null terminated.

@@ -63,21 +67,21 @@

 }

 namespace {

 struct NamedBufferAlloc {

   const Twine &Name;

   NamedBufferAlloc(const Twine &Name) : Name(Name) {}

 };

 }

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

   CopyStringRef(Mem + N, NameRef);

   return Mem;

 }

 namespace {

 /// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.

 class MemoryBufferMem : public MemoryBuffer {

@@ -156,21 +160,21 @@

 MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {

   std::unique_ptr<MemoryBuffer> SB = getNewUninitMemBuffer(Size, BufferName);

   if (!SB)

     return nullptr;

   memset(const_cast<char*>(SB->getBufferStart()), 0, Size);

   return SB;

 }

 ErrorOr<std::unique_ptr<MemoryBuffer>>

 MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize) {

-  SmallString<256> NameBuf;

+  SmallString<PATH_MAX> NameBuf;

   StringRef NameRef = Filename.toStringRef(NameBuf);

   if (NameRef == "-")

     return getSTDIN();

   return getFile(Filename, FileSize);

 }

 ErrorOr<std::unique_ptr<MemoryBuffer>>

 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize, 

                            uint64_t Offset) {

--- lib/Support/Unix/Program.inc	2014-12-01 16:52:01.000000000 -0800

+++ lib/Support/Unix/Program.inc	2015-09-19 15:34:57.144042911 -0700

@@ -31,23 +31,20 @@

 #if HAVE_SIGNAL_H

 #include <signal.h>

 #endif

 #if HAVE_FCNTL_H

 #include <fcntl.h>

 #endif

 #if HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #ifdef HAVE_POSIX_SPAWN

-#ifdef __sun__

-#define  _RESTRICT_KYWD

-#endif

 #include <spawn.h>

 #if !defined(__APPLE__)

   extern char **environ;

 #else

 #include <crt_externs.h> // _NSGetEnviron

 #endif

 #endif

 namespace llvm {

--- lib/TableGen/Main.cpp	2014-12-10 23:04:54.000000000 -0800

+++ lib/TableGen/Main.cpp	2015-09-19 18:04:08.147911223 -0700

@@ -21,97 +21,118 @@

 #include "llvm/Support/MemoryBuffer.h"

 #include "llvm/Support/ToolOutputFile.h"

 #include "llvm/TableGen/Error.h"

 #include "llvm/TableGen/Main.h"

 #include "llvm/TableGen/Record.h"

 #include <algorithm>

 #include <cstdio>

 #include <system_error>

 using namespace llvm;

-namespace {

-  cl::opt<std::string>

-  OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"),

-                 cl::init("-"));

-

-  cl::opt<std::string>

-  DependFilename("d",

-                 cl::desc("Dependency filename"),

-                 cl::value_desc("filename"),

-                 cl::init(""));

-

-  cl::opt<std::string>

-  InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));

-

-  cl::list<std::string>

-  IncludeDirs("I", cl::desc("Directory of include files"),

-              cl::value_desc("directory"), cl::Prefix);

-}

+static cl::opt<std::string>

+OutputFilename(cl::Prefix, "o",

+               cl::desc("Output filename"),

+               cl::value_desc("filename"),

+               cl::NotHidden,

+               cl::Optional,

+               cl::init("-"),

+               cl::ValueRequired);

+

+static cl::opt<std::string>

+DependFilename(cl::Prefix, "d",

+               cl::desc("Dependency filename"),

+               cl::value_desc("filename"),

+               cl::NotHidden,

+               cl::Optional,

+               cl::init(""),

+               cl::ValueRequired);

+

+static cl::opt<std::string>

+InputFilename(cl::Positional, "<input file>",

+              cl::desc("<input file>"),

+              cl::value_desc("Input filename"),

+              cl::NotHidden,

+              cl::Optional,

+              cl::init("-"),

+              cl::ValuePositionalNoArgs);

+

+static cl::list<std::string>

+IncludeDirs(cl::Prefix, "I",

+            cl::desc("Directory of include files"),

+            cl::value_desc("directory"),

+            cl::NotHidden,

+            cl::ZeroOrMore,

+            cl::ValueRequired);

 /// \brief Create a dependency file for `-d` option.

 ///

 /// This functionality is really only for the benefit of the build system.

 /// It is similar to GCC's `-M*` family of options.

 static int createDependencyFile(const TGParser &Parser, const char *argv0) {

   if (OutputFilename == "-") {

     errs() << argv0 << ": the option -d must be used together with -o\n";

     return 1;

   }

   std::error_code EC;

   tool_output_file DepOut(DependFilename, EC, sys::fs::F_Text);

   if (EC) {

     errs() << argv0 << ": error opening " << DependFilename << ":"

            << EC.message() << "\n";

     return 1;

   }

+

   DepOut.os() << OutputFilename << ":";

+

   for (const auto &Dep : Parser.getDependencies()) {

     DepOut.os() << ' ' << Dep.first;

   }

   DepOut.os() << "\n";

   DepOut.keep();

   return 0;

 }

 namespace llvm {

 int TableGenMain(char *argv0, TableGenMainFn *MainFn) {

   RecordKeeper Records;

   // Parse the input file.

+  llvm::Twine TFN(InputFilename);

   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =

-      MemoryBuffer::getFileOrSTDIN(InputFilename);

+      MemoryBuffer::getFileOrSTDIN(TFN);

+

   if (std::error_code EC = FileOrErr.getError()) {

     errs() << "Could not open input file '" << InputFilename

-           << "': " << EC.message() << "\n";

+      << "': " << EC.message() << "\n";

     return 1;

   }

   // Tell SrcMgr about this buffer, which is what TGParser will pick up.

   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());

   // Record the location of the include directory so that the lexer can find

   // it later.

-  SrcMgr.setIncludeDirs(IncludeDirs);

+  SrcMgr.setIncludeDirs(IncludeDirs.getStorage());

   TGParser Parser(SrcMgr, Records);

   if (Parser.ParseFile())

     return 1;

   std::error_code EC;

   tool_output_file Out(OutputFilename, EC, sys::fs::F_Text);

   if (EC) {

     errs() << argv0 << ": error opening " << OutputFilename << ":"

            << EC.message() << "\n";

     return 1;

   }

+

   if (!DependFilename.empty()) {

     if (int Ret = createDependencyFile(Parser, argv0))

       return Ret;

   }

   if (MainFn(Out.os(), Records))

     return 1;

   if (ErrorsPrinted > 0) {

     errs() << argv0 << ": " << ErrorsPrinted << " errors.\n";

--- utils/TableGen/TableGen.cpp	2014-12-10 23:04:54.000000000 -0800

+++ utils/TableGen/TableGen.cpp	2015-09-14 16:23:45.000000000 -0700

@@ -37,67 +37,67 @@

   GenFastISel,

   GenSubtarget,

   GenIntrinsic,

   GenTgtIntrinsic,

   PrintEnums,

   PrintSets,

   GenOptParserDefs,

   GenCTags

 };

-namespace {

-  cl::opt<ActionType>

-  Action(cl::desc("Action to perform:"),

-         cl::values(clEnumValN(PrintRecords, "print-records",

-                               "Print all records to stdout (default)"),

-                    clEnumValN(GenEmitter, "gen-emitter",

-                               "Generate machine code emitter"),

-                    clEnumValN(GenRegisterInfo, "gen-register-info",

-                               "Generate registers and register classes info"),

-                    clEnumValN(GenInstrInfo, "gen-instr-info",

-                               "Generate instruction descriptions"),

-                    clEnumValN(GenCallingConv, "gen-callingconv",

-                               "Generate calling convention descriptions"),

-                    clEnumValN(GenAsmWriter, "gen-asm-writer",

-                               "Generate assembly writer"),

-                    clEnumValN(GenDisassembler, "gen-disassembler",

-                               "Generate disassembler"),

-                    clEnumValN(GenPseudoLowering, "gen-pseudo-lowering",

-                               "Generate pseudo instruction lowering"),

-                    clEnumValN(GenAsmMatcher, "gen-asm-matcher",

-                               "Generate assembly instruction matcher"),

-                    clEnumValN(GenDAGISel, "gen-dag-isel",

-                               "Generate a DAG instruction selector"),

-                    clEnumValN(GenDFAPacketizer, "gen-dfa-packetizer",

-                               "Generate DFA Packetizer for VLIW targets"),

-                    clEnumValN(GenFastISel, "gen-fast-isel",

-                               "Generate a \"fast\" instruction selector"),

-                    clEnumValN(GenSubtarget, "gen-subtarget",

-                               "Generate subtarget enumerations"),

-                    clEnumValN(GenIntrinsic, "gen-intrinsic",

-                               "Generate intrinsic information"),

-                    clEnumValN(GenTgtIntrinsic, "gen-tgt-intrinsic",

-                               "Generate target intrinsic information"),

-                    clEnumValN(PrintEnums, "print-enums",

-                               "Print enum values for a class"),

-                    clEnumValN(PrintSets, "print-sets",

-                               "Print expanded sets for testing DAG exprs"),

-                    clEnumValN(GenOptParserDefs, "gen-opt-parser-defs",

-                               "Generate option definitions"),

-                    clEnumValN(GenCTags, "gen-ctags",

-                               "Generate ctags-compatible index"),

-                    clEnumValEnd));

+static cl::opt<ActionType>

+Action(cl::desc("Action to perform:"),

+       cl::values(clEnumValN(PrintRecords, "print-records",

+                             "Print all records to stdout (default)"),

+                  clEnumValN(GenEmitter, "gen-emitter",

+                             "Generate machine code emitter"),

+                  clEnumValN(GenRegisterInfo, "gen-register-info",

+                             "Generate registers and register classes info"),

+                  clEnumValN(GenInstrInfo, "gen-instr-info",

+                             "Generate instruction descriptions"),

+                  clEnumValN(GenCallingConv, "gen-callingconv",

+                             "Generate calling convention descriptions"),

+                  clEnumValN(GenAsmWriter, "gen-asm-writer",

+                             "Generate assembly writer"),

+                  clEnumValN(GenDisassembler, "gen-disassembler",

+                             "Generate disassembler"),

+                  clEnumValN(GenPseudoLowering, "gen-pseudo-lowering",

+                             "Generate pseudo instruction lowering"),

+                  clEnumValN(GenAsmMatcher, "gen-asm-matcher",

+                             "Generate assembly instruction matcher"),

+                  clEnumValN(GenDAGISel, "gen-dag-isel",

+                             "Generate a DAG instruction selector"),

+                  clEnumValN(GenDFAPacketizer, "gen-dfa-packetizer",

+                             "Generate DFA Packetizer for VLIW targets"),

+                  clEnumValN(GenFastISel, "gen-fast-isel",

+                             "Generate a \"fast\" instruction selector"),

+                  clEnumValN(GenSubtarget, "gen-subtarget",

+                             "Generate subtarget enumerations"),

+                  clEnumValN(GenIntrinsic, "gen-intrinsic",

+                             "Generate intrinsic information"),

+                  clEnumValN(GenTgtIntrinsic, "gen-tgt-intrinsic",

+                             "Generate target intrinsic information"),

+                  clEnumValN(PrintEnums, "print-enums",

+                             "Print enum values for a class"),

+                  clEnumValN(PrintSets, "print-sets",

+                             "Print expanded sets for testing DAG exprs"),

+                  clEnumValN(GenOptParserDefs, "gen-opt-parser-defs",

+                             "Generate option definitions"),

+                  clEnumValN(GenCTags, "gen-ctags",

+                             "Generate ctags-compatible index"),

+                  clEnumValEnd));

-  cl::opt<std::string>

-  Class("class", cl::desc("Print Enum list for this class"),

-          cl::value_desc("class name"));

+static cl::opt<std::string>

+Class("class", cl::desc("Print Enum list for this class"),

+      cl::value_desc("class name"));

+namespace {

 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {

   switch (Action) {

   case PrintRecords:

     OS << Records;           // No argument, dump all contents

     break;

   case GenEmitter:

     EmitCodeEmitter(Records, OS);

     break;

   case GenRegisterInfo:

     EmitRegisterInfo(Records, OS);

--- tools/clang/utils/TableGen/TableGen.cpp	2015-09-19 19:30:26.983452195 -0700

+++ tools/clang/utils/TableGen/TableGen.cpp	2015-09-19 23:12:38.299907988 -0700

@@ -48,101 +48,99 @@

   GenClangCommentHTMLTagsProperties,

   GenClangCommentHTMLNamedCharacterReferences,

   GenClangCommentCommandInfo,

   GenClangCommentCommandList,

   GenArmNeon,

   GenArmNeonSema,

   GenArmNeonTest,

   GenAttrDocs

 };

-namespace {

-cl::opt<ActionType> Action(

-    cl::desc("Action to perform:"),

-    cl::values(

-        clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",

-                   "Generate clang attribute clases"),

-        clEnumValN(GenClangAttrParserStringSwitches,

-                   "gen-clang-attr-parser-string-switches",

-                   "Generate all parser-related attribute string switches"),

-        clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",

-                   "Generate clang attribute implementations"),

-        clEnumValN(GenClangAttrList, "gen-clang-attr-list",

-                   "Generate a clang attribute list"),

-        clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",

-                   "Generate clang PCH attribute reader"),

-        clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",

-                   "Generate clang PCH attribute writer"),

-        clEnumValN(GenClangAttrHasAttributeImpl,

-                   "gen-clang-attr-has-attribute-impl",

-                   "Generate a clang attribute spelling list"),

-        clEnumValN(GenClangAttrSpellingListIndex,

-                   "gen-clang-attr-spelling-index",

-                   "Generate a clang attribute spelling index"),

-        clEnumValN(GenClangAttrASTVisitor,

-                   "gen-clang-attr-ast-visitor",

-                   "Generate a recursive AST visitor for clang attributes"),

-        clEnumValN(GenClangAttrTemplateInstantiate,

-                   "gen-clang-attr-template-instantiate",

-                   "Generate a clang template instantiate code"),

-        clEnumValN(GenClangAttrParsedAttrList,

-                   "gen-clang-attr-parsed-attr-list",

-                   "Generate a clang parsed attribute list"),

-        clEnumValN(GenClangAttrParsedAttrImpl,

-                   "gen-clang-attr-parsed-attr-impl",

-                   "Generate the clang parsed attribute helpers"),

-        clEnumValN(GenClangAttrParsedAttrKinds,

-                   "gen-clang-attr-parsed-attr-kinds",

-                   "Generate a clang parsed attribute kinds"),

-        clEnumValN(GenClangAttrDump, "gen-clang-attr-dump",

-                   "Generate clang attribute dumper"),

-        clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",

-                   "Generate Clang diagnostics definitions"),

-        clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",

-                   "Generate Clang diagnostic groups"),

-        clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",

-                   "Generate Clang diagnostic name index"),

-        clEnumValN(GenClangCommentNodes, "gen-clang-comment-nodes",

-                   "Generate Clang AST comment nodes"),

-        clEnumValN(GenClangDeclNodes, "gen-clang-decl-nodes",

-                   "Generate Clang AST declaration nodes"),

-        clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",

-                   "Generate Clang AST statement nodes"),

-        clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",

-                   "Generate Clang Static Analyzer checkers"),

-        clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",

-                   "Generate efficient matchers for HTML tag "

-                   "names that are used in documentation comments"),

-        clEnumValN(GenClangCommentHTMLTagsProperties,

-                   "gen-clang-comment-html-tags-properties",

-                   "Generate efficient matchers for HTML tag "

-                   "properties"),

-        clEnumValN(GenClangCommentHTMLNamedCharacterReferences,

-                   "gen-clang-comment-html-named-character-references",

-                   "Generate function to translate named character "

-                   "references to UTF-8 sequences"),

-        clEnumValN(GenClangCommentCommandInfo, "gen-clang-comment-command-info",

-                   "Generate command properties for commands that "

-                   "are used in documentation comments"),

-        clEnumValN(GenClangCommentCommandList, "gen-clang-comment-command-list",

-                   "Generate list of commands that are used in "

-                   "documentation comments"),

-        clEnumValN(GenArmNeon, "gen-arm-neon", "Generate arm_neon.h for clang"),

-        clEnumValN(GenArmNeonSema, "gen-arm-neon-sema",

-                   "Generate ARM NEON sema support for clang"),

-        clEnumValN(GenArmNeonTest, "gen-arm-neon-test",

-                   "Generate ARM NEON tests for clang"),

-        clEnumValN(GenAttrDocs, "gen-attr-docs",

-                   "Generate attribute documentation"),

-        clEnumValEnd));

+static cl::opt<ActionType>

+Action(cl::desc("Action to perform:"),

+       cl::values(clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",

+                             "Generate clang attribute clases"),

+                  clEnumValN(GenClangAttrParserStringSwitches,

+                             "gen-clang-attr-parser-string-switches",

+                             "Generate all parser-related attribute string switches"),

+                  clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",

+                             "Generate clang attribute implementations"),

+                  clEnumValN(GenClangAttrList, "gen-clang-attr-list",

+                             "Generate a clang attribute list"),

+                  clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",

+                             "Generate clang PCH attribute reader"),

+                  clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",

+                             "Generate clang PCH attribute writer"),

+                  clEnumValN(GenClangAttrHasAttributeImpl,

+                             "gen-clang-attr-has-attribute-impl",

+                             "Generate a clang attribute spelling list"),

+                  clEnumValN(GenClangAttrSpellingListIndex,

+                             "gen-clang-attr-spelling-index",

+                             "Generate a clang attribute spelling index"),

+                  clEnumValN(GenClangAttrASTVisitor,

+                             "gen-clang-attr-ast-visitor",

+                             "Generate a recursive AST visitor for clang attributes"),

+                  clEnumValN(GenClangAttrTemplateInstantiate,

+                             "gen-clang-attr-template-instantiate",

+                             "Generate a clang template instantiate code"),

+                  clEnumValN(GenClangAttrParsedAttrList,

+                             "gen-clang-attr-parsed-attr-list",

+                             "Generate a clang parsed attribute list"),

+                  clEnumValN(GenClangAttrParsedAttrImpl,

+                             "gen-clang-attr-parsed-attr-impl",

+                             "Generate the clang parsed attribute helpers"),

+                  clEnumValN(GenClangAttrParsedAttrKinds,

+                             "gen-clang-attr-parsed-attr-kinds",

+                             "Generate a clang parsed attribute kinds"),

+                  clEnumValN(GenClangAttrDump, "gen-clang-attr-dump",

+                             "Generate clang attribute dumper"),

+                  clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",

+                             "Generate Clang diagnostics definitions"),

+                  clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",