# 22902339 memory corruption caused by undefined behavior in LLVM IR Module
# 24314687 static initialization of optimization passes doesn't work as
# intended
# 3.9.X for upstream.
--- include/llvm/IR/BasicBlock.h	2015-11-10 18:26:42.000000000 -0800
+++ include/llvm/IR/BasicBlock.h	2016-05-28 16:37:28.925076023 -0700
@@ -78,10 +78,11 @@
   LLVMContext &getContext() const;
 
   /// Instruction iterators...
-  typedef InstListType::iterator iterator;
-  typedef InstListType::const_iterator const_iterator;
-  typedef InstListType::reverse_iterator reverse_iterator;
-  typedef InstListType::const_reverse_iterator const_reverse_iterator;
+  typedef SymbolTableList<Instruction>::iterator iterator;
+  typedef SymbolTableList<Instruction>::const_iterator const_iterator;
+  typedef SymbolTableList<Instruction>::reverse_iterator reverse_iterator;
+  typedef SymbolTableList<Instruction>::const_reverse_iterator
+          const_reverse_iterator;
 
   /// \brief Creates a new BasicBlock.
   ///
@@ -148,8 +149,8 @@
   /// suitable for inserting a non-PHI instruction.
   ///
   /// In particular, it skips all PHIs and LandingPad instructions.
-  iterator getFirstInsertionPt();
-  const_iterator getFirstInsertionPt() const {
+  BasicBlock::iterator getFirstInsertionPt();
+  BasicBlock::const_iterator getFirstInsertionPt() const {
     return const_cast<BasicBlock*>(this)->getFirstInsertionPt();
   }
 
###
--- include/llvm/IR/Value.h	2016-02-04 08:59:45.000000000 -0800
+++ include/llvm/IR/Value.h	2016-05-29 12:21:18.779271419 -0700
@@ -74,6 +74,7 @@
 
   const unsigned char SubclassID;   // Subclass identifier (for isa/dyn_cast)
   unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
+
 protected:
   /// \brief Hold subclass data that can be dropped.
   ///
@@ -113,17 +114,25 @@
 
 private:
   template <typename UseT> // UseT == 'Use' or 'const Use'
-  class use_iterator_impl
-      : public std::iterator<std::forward_iterator_tag, UseT *> {
+  class use_iterator_impl :
+    public std::iterator<std::forward_iterator_tag, UseT *> {
     UseT *U;
-    explicit use_iterator_impl(UseT *u) : U(u) {}
+
+    explicit use_iterator_impl(UseT *u)
+      : std::iterator<std::forward_iterator_tag, UseT *>(), U(u) { }
     friend class Value;
 
   public:
-    use_iterator_impl() : U() {}
+    use_iterator_impl()
+      : std::iterator<std::forward_iterator_tag, UseT *>(), U(nullptr) { }
 
-    bool operator==(const use_iterator_impl &x) const { return U == x.U; }
-    bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }
+    bool operator==(const use_iterator_impl &x) const {
+      return U == x.U;
+    }
+
+    bool operator!=(const use_iterator_impl &x) const {
+      return !operator==(x);
+    }
 
     use_iterator_impl &operator++() { // Preincrement
       assert(U && "Cannot increment end iterator!");
@@ -150,18 +159,28 @@
 
   template <typename UserTy> // UserTy == 'User' or 'const User'
   class user_iterator_impl
-      : public std::iterator<std::forward_iterator_tag, UserTy *> {
+  : public std::iterator<std::forward_iterator_tag, UserTy *> {
+  private:
     use_iterator_impl<Use> UI;
-    explicit user_iterator_impl(Use *U) : UI(U) {}
+
+    explicit user_iterator_impl(Use *U)
+      : std::iterator<std::forward_iterator_tag, UserTy *>(), UI(U) { }
     friend class Value;
 
   public:
-    user_iterator_impl() {}
+    user_iterator_impl()
+    : std::iterator<std::forward_iterator_tag, UserTy *>(), UI() { }
 
-    bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
-    bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }
+    bool operator==(const user_iterator_impl &x) const {
+      return UI == x.UI;
+    }
 
-    /// \brief Returns true if this iterator is equal to user_end() on the value.
+    bool operator!=(const user_iterator_impl &x) const {
+      return !operator==(x);
+    }
+
+    /// \brief Returns true if this iterator is equal to user_end()
+    /// on the value.
     bool atEnd() const { return *this == user_iterator_impl(); }
 
     user_iterator_impl &operator++() { // Preincrement
@@ -193,6 +212,7 @@
 
 protected:
   Value(Type *Ty, unsigned scid);
+
 public:
   virtual ~Value();
 
###
--- lib/IR/User.cpp	2015-09-23 18:00:49.000000000 -0700
+++ lib/IR/User.cpp	2016-05-29 12:13:16.188732011 -0700
@@ -12,6 +12,8 @@
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Operator.h"
 
+#include <cstdlib>
+
 namespace llvm {
 class BasicBlock;
 
@@ -42,33 +44,53 @@
 
 void User::allocHungoffUses(unsigned N, bool IsPhi) {
   assert(HasHungOffUses && "alloc must have hung off uses");
-
-  static_assert(AlignOf<Use>::Alignment >= AlignOf<Use::UserRef>::Alignment,
-                "Alignment is insufficient for 'hung-off-uses' pieces");
+  static_assert(AlignOf<Use>::Alignment >=
+                AlignOf<Use::UserRef>::Alignment,
+                "Insufficient alignment for 'hung-off-uses' pieces");
   static_assert(AlignOf<Use::UserRef>::Alignment >=
-                    AlignOf<BasicBlock *>::Alignment,
-                "Alignment is insufficient for 'hung-off-uses' pieces");
+                AlignOf<BasicBlock*>::Alignment,
+                "Insufficient alignment for 'hung-off-uses' pieces");
 
   // Allocate the array of Uses, followed by a pointer (with bottom bit set) to
   // the User.
   size_t size = N * sizeof(Use) + sizeof(Use::UserRef);
   if (IsPhi)
     size += N * sizeof(BasicBlock *);
-  Use *Begin = static_cast<Use*>(::operator new(size));
+
+  size_t Alignment =
+    std::max<size_t>(AlignOf<Use>::Alignment,
+                     std::max<size_t>(AlignOf<BasicBlock*>::Alignment,
+                                      AlignOf<Use::UserRef>::Alignment));
+  size = llvm::RoundUpToAlignment(size, Alignment);
+  void *Mem;
+
+  if (posix_memalign(&Mem, Alignment, size) != 0) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": posix_memalign(3c) failed!\n";
+    abort();
+  }
+
+  (void) std::memset(Mem, 0, size);
+  Use *Begin = reinterpret_cast<Use*>(Mem);
   Use *End = Begin + N;
   (void) new(End) Use::UserRef(const_cast<User*>(this), 1);
   setOperandList(Use::initTags(Begin, End));
 }
 
 void User::growHungoffUses(unsigned NewNumUses, bool IsPhi) {
-  assert(HasHungOffUses && "realloc must have hung off uses");
-
+  assert(HasHungOffUses && "alloc must have hung off uses");
   unsigned OldNumUses = getNumOperands();
 
   // We don't support shrinking the number of uses.  We wouldn't have enough
   // space to copy the old uses in to the new space.
   assert(NewNumUses > OldNumUses && "realloc must grow num uses");
 
+  if (OldNumUses >= NewNumUses) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": reallocation must grow new uses!\n";
+    abort();
+  }
+
   Use *OldOps = getOperandList();
   allocHungoffUses(NewNumUses, IsPhi);
   Use *NewOps = getOperandList();
@@ -101,7 +123,6 @@
 
 MutableArrayRef<uint8_t> User::getDescriptor() {
   assert(HasDescriptor && "Don't call otherwise!");
-  assert(!HasHungOffUses && "Invariant!");
 
   auto *DI = reinterpret_cast<DescriptorInfo *>(getIntrusiveOperands()) - 1;
   assert(DI->SizeInBytes != 0 && "Should not have had a descriptor otherwise!");
@@ -114,20 +135,31 @@
 //                         User operator new Implementations
 //===----------------------------------------------------------------------===//
 
-void *User::allocateFixedOperandUser(size_t Size, unsigned Us,
-                                     unsigned DescBytes) {
+void* LLVM_ATTRIBUTE_NOINLINE
+User::allocateFixedOperandUser(size_t Size, unsigned Us, unsigned DescBytes) {
   assert(Us < (1u << NumUserOperandsBits) && "Too many operands");
 
   static_assert(sizeof(DescriptorInfo) % sizeof(void *) == 0, "Required below");
 
   unsigned DescBytesToAllocate =
-      DescBytes == 0 ? 0 : (DescBytes + sizeof(DescriptorInfo));
+    DescBytes == 0 ?  0 : (DescBytes + sizeof(DescriptorInfo));
+  DescBytesToAllocate = llvm::RoundUpToAlignment(DescBytesToAllocate, 8U);
   assert(DescBytesToAllocate % sizeof(void *) == 0 &&
          "We need this to satisfy alignment constraints for Uses");
 
-  uint8_t *Storage = static_cast<uint8_t *>(
-      ::operator new(Size + sizeof(Use) * Us + DescBytesToAllocate));
-  Use *Start = reinterpret_cast<Use *>(Storage + DescBytesToAllocate);
+  unsigned AllocSize = Size + sizeof(Use) * Us + DescBytesToAllocate;
+  AllocSize = std::max<unsigned>(AllocSize, alignof(void*));
+
+  uint8_t *Storage;
+  if (posix_memalign(reinterpret_cast<void**>(&Storage),
+                     llvm::AlignOf<uint64_t>::Alignment, AllocSize) != 0) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": posix_memalign(3c) failed!\n";
+    abort();
+  }
+
+  Use *Start = reinterpret_cast<Use*>(reinterpret_cast<void*>(
+      reinterpret_cast<uint8_t*>(Storage) + DescBytesToAllocate));
   Use *End = Start + Us;
   User *Obj = reinterpret_cast<User*>(End);
   Obj->NumUserOperands = Us;
@@ -153,7 +185,16 @@
 
 void *User::operator new(size_t Size) {
   // Allocate space for a single Use*
-  void *Storage = ::operator new(Size + sizeof(Use *));
+  void *Storage;
+  unsigned AllocSize = Size + sizeof(Use*);
+  AllocSize = std::max<unsigned>(AllocSize, sizeof(void*));
+  if (posix_memalign(&Storage, llvm::AlignOf<uint64_t>::Alignment,
+                     AllocSize) != 0) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": posix_memalign(3c) failed!\n";
+    abort();
+  }
+
   Use **HungOffOperandList = static_cast<Use **>(Storage);
   User *Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
   Obj->NumUserOperands = 0;
@@ -170,7 +211,7 @@
 void User::operator delete(void *Usr) {
   // Hung off uses use a single Use* before the User, while other subclasses
   // use a Use[] allocated prior to the user.
-  User *Obj = static_cast<User *>(Usr);
+  User *Obj = reinterpret_cast<User *>(Usr);
   if (Obj->HasHungOffUses) {
     assert(!Obj->HasDescriptor && "not supported!");
 
@@ -178,19 +219,19 @@
     // drop the hung off uses.
     Use::zap(*HungOffOperandList, *HungOffOperandList + Obj->NumUserOperands,
              /* Delete */ true);
-    ::operator delete(HungOffOperandList);
+    std::free(reinterpret_cast<void*>(HungOffOperandList));
   } else if (Obj->HasDescriptor) {
     Use *UseBegin = static_cast<Use *>(Usr) - Obj->NumUserOperands;
     Use::zap(UseBegin, UseBegin + Obj->NumUserOperands, /* Delete */ false);
 
     auto *DI = reinterpret_cast<DescriptorInfo *>(UseBegin) - 1;
-    uint8_t *Storage = reinterpret_cast<uint8_t *>(DI) - DI->SizeInBytes;
-    ::operator delete(Storage);
+    uint64_t *Storage = reinterpret_cast<uint64_t *>(DI) - DI->SizeInBytes;
+    std::free(reinterpret_cast<void*>(Storage));
   } else {
-    Use *Storage = static_cast<Use *>(Usr) - Obj->NumUserOperands;
+    Use *Storage = reinterpret_cast<Use *>(Usr) - Obj->NumUserOperands;
     Use::zap(Storage, Storage + Obj->NumUserOperands,
              /* Delete */ false);
-    ::operator delete(Storage);
+    std::free(reinterpret_cast<void*>(Storage));
   }
 }
 
###
--- include/llvm/IR/User.h	2015-12-18 23:52:49.000000000 -0900
+++ include/llvm/IR/User.h	2016-07-06 18:49:29.963198410 -0800
@@ -40,7 +40,7 @@
   friend struct HungoffOperandTraits;
   virtual void anchor();
 
-  LLVM_ATTRIBUTE_ALWAYS_INLINE inline static void *
+  static void* LLVM_ATTRIBUTE_NOINLINE
   allocateFixedOperandUser(size_t, unsigned, unsigned);
 
 protected:
###
--- include/llvm/IR/Attributes.h	2015-12-22 18:57:37.000000000 -0500
+++ include/llvm/IR/Attributes.h	2016-05-08 23:19:20.515430339 -0400
@@ -399,20 +399,25 @@
 
 public:
   AttrBuilder()
-      : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0),
-        DerefOrNullBytes(0) {}
+    : Attrs(0), TargetDepAttrs(), Alignment(0), StackAlignment(0),
+  DerefBytes(0), DerefOrNullBytes(0) { }
+
   explicit AttrBuilder(uint64_t Val)
-      : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0),
-        DerefOrNullBytes(0) {
+    : Attrs(0), TargetDepAttrs(), Alignment(0), StackAlignment(0),
+    DerefBytes(0), DerefOrNullBytes(0) {
     addRawValue(Val);
   }
+
   AttrBuilder(const Attribute &A)
-      : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0),
-        DerefOrNullBytes(0) {
+    : Attrs(0), TargetDepAttrs(), Alignment(0), StackAlignment(0),
+    DerefBytes(0), DerefOrNullBytes(0) {
     addAttribute(A);
   }
+
   AttrBuilder(AttributeSet AS, unsigned Idx);
 
+  ~AttrBuilder() { }
+
   void clear();
 
   /// \brief Add an attribute to the builder.
###
--- include/llvm/IR/IRBuilder.h	2016-02-18 16:08:56.000000000 -0800
+++ include/llvm/IR/IRBuilder.h	2016-05-09 19:14:26.534949228 -0700
@@ -64,13 +64,15 @@
   ArrayRef<OperandBundleDef> DefaultOperandBundles;
 
 public:
-  IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
+  IRBuilderBase(LLVMContext &Ctx, MDNode *FPMathTag = nullptr,
                 ArrayRef<OperandBundleDef> OpBundles = None)
-      : Context(context), DefaultFPMathTag(FPMathTag), FMF(),
-        DefaultOperandBundles(OpBundles) {
-    ClearInsertionPoint();
+  : CurDbgLocation(), BB(nullptr), InsertPt(), Context(Ctx),
+  DefaultFPMathTag(FPMathTag), FMF(), DefaultOperandBundles(OpBundles) {
+    InsertPt.reset(nullptr);
   }
 
+  virtual ~IRBuilderBase() { }
+
   //===--------------------------------------------------------------------===//
   // Builder configuration methods
   //===--------------------------------------------------------------------===//
###
--- lib/IR/IRBuilder.cpp	2015-11-18 21:56:52.000000000 -0800
+++ lib/IR/IRBuilder.cpp	2016-05-13 17:40:40.999056490 -0700
@@ -18,8 +18,15 @@
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Statepoint.h"
+#include "llvm/LinkAllIR.h"
 using namespace llvm;
 
+namespace llvm {
+  /// See the file ${top_srcdir}/include/llvm/LinkAllIR.h for the
+  /// explanation for this hack.
+  ForceVMCoreLinking *ForceVMCoreLinking::FVMCL = new ForceVMCoreLinking();
+}
+
 /// CreateGlobalString - Make a new global variable with an initializer that
 /// has array of i8 type filled in with the nul terminated string value
 /// specified.  If Name is specified, it is the name of the global variable
###
--- lib/IR/Verifier.cpp	2016-01-12 18:31:14.000000000 -0800
+++ lib/IR/Verifier.cpp	2016-05-14 07:42:08.348333940 -0700
@@ -578,8 +578,12 @@
 void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
                                    const GlobalAlias &GA, const Constant &C) {
   if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
+#if 0
+    // Check the DeclarationForLinker() for all the extern symbol references.
+    // This should not happen here in any scenario.
     Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition",
            &GA);
+#endif
 
     if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
       Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
###
--- include/llvm/IR/Metadata.h	2016-01-11 13:37:41.000000000 -0800
+++ include/llvm/IR/Metadata.h	2016-05-10 07:11:35.580234020 -0700
@@ -25,6 +25,7 @@
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
 #include <type_traits>
 
 namespace llvm {
@@ -42,6 +43,7 @@
 /// This is a root class for typeless data in the IR.
 class Metadata {
   friend class ReplaceableMetadataImpl;
+  friend class MDNode;
 
   /// \brief RTTI.
   const unsigned char SubclassID;
@@ -51,7 +53,8 @@
   enum StorageType { Uniqued, Distinct, Temporary };
 
   /// \brief Storage flag for non-uniqued, otherwise unowned, metadata.
-  unsigned Storage : 2;
+  unsigned Storage;
+
   // TODO: expose remaining bits to subclasses.
 
   unsigned short SubclassData16;
@@ -91,8 +94,9 @@
 
 protected:
   Metadata(unsigned ID, StorageType Storage)
-      : SubclassID(ID), Storage(Storage), SubclassData16(0), SubclassData32(0) {
-  }
+    : SubclassID(ID), Storage(Storage), SubclassData16(0),
+    SubclassData32(0) { }
+
   ~Metadata() = default;
 
   /// \brief Default handling of a changed operand, which asserts.
@@ -283,13 +287,15 @@
   LLVMContext &Context;
   uint64_t NextIndex;
   SmallDenseMap<void *, std::pair<OwnerTy, uint64_t>, 4> UseMap;
+
   /// Flag that can be set to false if this metadata should not be
   /// RAUW'ed, e.g. if it is used as the key of a map.
   bool CanReplace;
 
 public:
-  ReplaceableMetadataImpl(LLVMContext &Context)
-      : Context(Context), NextIndex(0), CanReplace(true) {}
+  ReplaceableMetadataImpl(LLVMContext &Ctx)
+    : Context(Ctx), NextIndex(0), UseMap(), CanReplace(true) { }
+
   ~ReplaceableMetadataImpl() {
     assert(UseMap.empty() && "Cannot destroy in-use replaceable metadata");
   }
@@ -327,7 +333,7 @@
 /// Because of full uniquing support, each value is only wrapped by a single \a
 /// ValueAsMetadata object, so the lookup maps are far more efficient than
 /// those using ValueHandleBase.
-class ValueAsMetadata : public Metadata, ReplaceableMetadataImpl {
+class ValueAsMetadata : public Metadata, public ReplaceableMetadataImpl {
   friend class ReplaceableMetadataImpl;
   friend class LLVMContextImpl;
 
@@ -343,6 +349,7 @@
       : Metadata(ID, Uniqued), ReplaceableMetadataImpl(V->getContext()), V(V) {
     assert(V && "Expected valid value");
   }
+
   ~ValueAsMetadata() = default;
 
 public:
@@ -396,6 +403,7 @@
   static ConstantAsMetadata *get(Constant *C) {
     return ValueAsMetadata::getConstant(C);
   }
+
   static ConstantAsMetadata *getIfExists(Constant *C) {
     return ValueAsMetadata::getConstantIfExists(C);
   }
@@ -421,6 +429,7 @@
   static LocalAsMetadata *get(Value *Local) {
     return ValueAsMetadata::getLocal(Local);
   }
+
   static LocalAsMetadata *getIfExists(Value *Local) {
     return ValueAsMetadata::getLocalIfExists(Local);
   }
@@ -748,6 +757,7 @@
       : Ptr(ReplaceableUses.release()) {
     assert(getReplaceableUses() && "Expected non-null replaceable uses");
   }
+
   ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
 
   operator LLVMContext &() { return getContext(); }
@@ -756,11 +766,13 @@
   bool hasReplaceableUses() const {
     return Ptr.is<ReplaceableMetadataImpl *>();
   }
+
   LLVMContext &getContext() const {
     if (hasReplaceableUses())
       return getReplaceableUses()->getContext();
     return *Ptr.get<LLVMContext *>();
   }
+
   ReplaceableMetadataImpl *getReplaceableUses() const {
     if (hasReplaceableUses())
       return Ptr.get<ReplaceableMetadataImpl *>();
@@ -820,10 +832,11 @@
 class MDNode : public Metadata {
   friend class ReplaceableMetadataImpl;
   friend class LLVMContextImpl;
+  friend class MDNodeFwdDecl;
+  friend class MDTuple;
 
   MDNode(const MDNode &) = delete;
   void operator=(const MDNode &) = delete;
-  void *operator new(size_t) = delete;
 
   unsigned NumOperands;
   unsigned NumUnresolved;
@@ -831,17 +844,21 @@
 protected:
   ContextAndReplaceableUses Context;
 
-  void *operator new(size_t Size, unsigned NumOps);
-  void operator delete(void *Mem);
+  static void *operator new(size_t Size, unsigned NumOps) throw();
+  static void operator delete(void *Mem) throw();
 
   /// \brief Required by std, but never called.
-  void operator delete(void *, unsigned) {
-    llvm_unreachable("Constructor throws?");
+  static void operator delete(void *, unsigned) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": This should never be called!\n";
+    abort();
   }
 
   /// \brief Required by std, but never called.
-  void operator delete(void *, unsigned, bool) {
-    llvm_unreachable("Constructor throws?");
+  static void operator delete(void *, unsigned, bool) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": This should never be called!\n";
+    abort();
   }
 
   MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
@@ -1082,6 +1099,7 @@
       : MDNode(C, MDTupleKind, Storage, Vals) {
     setHash(Hash);
   }
+
   ~MDTuple() { dropAllReferences(); }
 
   void setHash(unsigned Hash) { SubclassData32 = Hash; }
@@ -1096,12 +1114,16 @@
   }
 
 public:
+  void *operator new(size_t Size, unsigned NumOps) throw();
+  void operator delete(void *Mem) throw();
+
   /// \brief Get the hash, if any.
   unsigned getHash() const { return SubclassData32; }
 
   static MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
     return getImpl(Context, MDs, Uniqued);
   }
+
   static MDTuple *getIfExists(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
     return getImpl(Context, MDs, Uniqued, /* ShouldCreate */ false);
   }
@@ -1154,18 +1176,20 @@
 /// An iterator that transforms an \a MDNode::iterator into an iterator over a
 /// particular Metadata subclass.
 template <class T>
-class TypedMDOperandIterator
-    : std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void, T *> {
+class TypedMDOperandIterator : public std::iterator<std::input_iterator_tag, T *, std::ptrdiff_t, void, T *> {
+private:
   MDNode::op_iterator I = nullptr;
 
 public:
   TypedMDOperandIterator() = default;
   explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
   T *operator*() const { return cast_or_null<T>(*I); }
+
   TypedMDOperandIterator &operator++() {
     ++I;
     return *this;
   }
+
   TypedMDOperandIterator operator++(int) {
     TypedMDOperandIterator Temp(*this);
     ++I;
@@ -1180,6 +1204,7 @@
 /// This is a wrapper for \a MDTuple that makes it act like an array holding a
 /// particular type of metadata.
 template <class T> class MDTupleTypedArrayWrapper {
+private:
   const MDTuple *N = nullptr;
 
 public:
###
--- include/llvm/LinkAllIR.h	2014-01-13 01:26:24.000000000 -0800
+++ include/llvm/LinkAllIR.h	2016-07-06 07:55:18.900250515 -0800
@@ -32,22 +32,49 @@
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TimeValue.h"
+
 #include <cstdlib>
 
-namespace {
-  struct ForceVMCoreLinking {
+namespace llvm {
+  class ForceVMCoreLinking {
+  private:
     ForceVMCoreLinking() {
       // We must reference VMCore 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;
-      (void)new llvm::Module("", llvm::getGlobalContext());
-      (void)new llvm::UnreachableInst(llvm::getGlobalContext());
-      (void)    llvm::createVerifierPass(); 
+
+      // Hi, GCC. Please don't throw this function away.
+      asm("");
+
+      llvm::Module *M = new llvm::Module("", llvm::getGlobalContext());
+      (void) M;
+
+      llvm::Instruction *I =
+        new llvm::UnreachableInst(llvm::getGlobalContext());
+      (void) I;
+
+      FunctionPass *FP = llvm::createVerifierPass();
+      (void) FP;
     }
-  } ForceVMCoreLinking;
+
+  public:
+
+    static ForceVMCoreLinking *Initialize();
+
+    ~ForceVMCoreLinking() { }
+
+  private:
+    /// Initialization of this is done in lib/IR/IRBuilder.cpp
+    /// because of initialization ordering problems with global
+    /// static variables.  The design of this static initialization
+    /// dependency chain is completely broken.
+    static ForceVMCoreLinking *FVMCL;
+  };
 }
 
 #endif
+
###
--- lib/IR/AttributeImpl.h	2015-08-06 02:49:17.000000000 -0700
+++ lib/IR/AttributeImpl.h	2016-05-09 16:14:24.849498745 -0700
@@ -186,6 +186,11 @@
   }
 };
 
+static_assert(AlignOf<AttributeSetNode>::Alignment >=
+              AlignOf<Attribute>::Alignment,
+              "Insufficient alignment for objects appended to "
+              "AttributeSetNode");
+
 typedef std::pair<unsigned, AttributeSetNode *> IndexAttrPair;
 
 //===----------------------------------------------------------------------===//
@@ -279,6 +284,11 @@
   void dump() const;
 };
 
+static_assert(AlignOf<AttributeSetImpl>::Alignment >=
+              AlignOf<IndexAttrPair>::Alignment,
+              "Insufficient alignment for objects appended to "
+              "AttributeSetImpl");
+
 } // end llvm namespace
 
 #endif
###
--- lib/IR/Attributes.cpp	2016-01-03 14:43:40.000000000 -0500
+++ lib/IR/Attributes.cpp	2016-05-08 23:19:20.532430753 -0400
@@ -1133,8 +1133,8 @@
 //===----------------------------------------------------------------------===//
 
 AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
-    : Attrs(0), Alignment(0), StackAlignment(0), DerefBytes(0),
-      DerefOrNullBytes(0) {
+  : Attrs(0), TargetDepAttrs(), Alignment(0), StackAlignment(0),
+  DerefBytes(0), DerefOrNullBytes(0) {
   AttributeSetImpl *pImpl = AS.pImpl;
   if (!pImpl) return;
 
@@ -1185,7 +1185,9 @@
 }
 
 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
-  TargetDepAttrs[A] = V;
+  std::string AS = A.str();
+  std::string VS = V.str();
+  TargetDepAttrs[AS] = VS;
   return *this;
 }
 
@@ -1229,9 +1231,11 @@
 }
 
 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
-  std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
+  std::string AS = A.str();
+  std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(AS);
   if (I != TargetDepAttrs.end())
     TargetDepAttrs.erase(I);
+
   return *this;
 }
 
@@ -1241,6 +1245,12 @@
   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
   assert(Align <= 0x40000000 && "Alignment too large.");
 
+  if (!isPowerOf2_32(Align)) {
+    llvm::errs() << __PRETTY_FUNCTION__
+      << ": Alignment must be a power of two!\n";
+    abort();
+  }
+
   Attrs[Attribute::Alignment] = true;
   Alignment = Align;
   return *this;
@@ -1333,7 +1343,8 @@
 }
 
 bool AttrBuilder::contains(StringRef A) const {
-  return TargetDepAttrs.find(A) != TargetDepAttrs.end();
+  std::string AS = A.str();
+  return TargetDepAttrs.find(AS) != TargetDepAttrs.end();
 }
 
 bool AttrBuilder::hasAttributes() const {
@@ -1357,7 +1368,8 @@
         return true;
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute kind!");
-      return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
+      std::string AS = Attr.getKindAsString().str();
+      return TargetDepAttrs.find(AS) != TargetDepAttrs.end();
     }
   }
 
###
--- lib/IR/LegacyPassManager.cpp	2016-01-06 17:55:03.000000000 -0500
+++ lib/IR/LegacyPassManager.cpp	2016-05-08 23:19:20.532430753 -0400
@@ -59,28 +59,27 @@
   clEnumVal(Details   , "print pass details when it is executed"),
                              clEnumValEnd));
 
-namespace {
-typedef llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
-PassOptionList;
-}
-
 // Print IR out before/after specified passes.
-static PassOptionList
-PrintBefore("print-before",
-            llvm::cl::desc("Print IR before specified passes"),
-            cl::Hidden);
-
-static PassOptionList
-PrintAfter("print-after",
-           llvm::cl::desc("Print IR after specified passes"),
-           cl::Hidden);
+static llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
+PrintBefore(cl::Prefix, "print-before",
+            cl::desc("Print IR before specified passes"),
+            cl::value_desc("Print IR before specified passes"),
+            cl::Hidden,
+            cl::ZeroOrMore);
+
+static llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
+PrintAfter(cl::Prefix, "print-after",
+           cl::desc("Print IR after specified passes"),
+           cl::value_desc("Print IR after specified passes"),
+           cl::Hidden,
+           cl::ZeroOrMore);
 
 static cl::opt<bool>
-PrintBeforeAll("print-before-all",
+PrintBeforeAll(cl::NormalFormatting, "print-before-all",
                llvm::cl::desc("Print IR before each pass"),
                cl::init(false));
 static cl::opt<bool>
-PrintAfterAll("print-after-all",
+PrintAfterAll(cl::NormalFormatting, "print-after-all",
               llvm::cl::desc("Print IR after each pass"),
               cl::init(false));
 
@@ -94,8 +93,10 @@
 /// This is a helper to determine whether to print IR before or
 /// after a pass.
 
-static bool ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
-                                         PassOptionList &PassesToPrint) {
+static bool
+ShouldPrintBeforeOrAfterPass(const PassInfo *PI,
+                             llvm::cl::list<const llvm::PassInfo *, bool,
+                             PassNameParser> &PassesToPrint) {
   for (auto *PassInf : PassesToPrint) {
     if (PassInf)
       if (PassInf->getPassArgument() == PI->getPassArgument()) {
###.
--- lib/IR/Metadata.cpp	2016-01-11 13:37:41.000000000 -0800
+++ lib/IR/Metadata.cpp	2016-05-09 19:35:11.382012208 -0700
@@ -429,33 +429,75 @@
       "Alignment is insufficient after objects prepended to " #CLASS);
 #include "llvm/IR/Metadata.def"
 
-void *MDNode::operator new(size_t Size, unsigned NumOps) {
+void *MDNode::operator new(size_t Size, unsigned NumOps) throw() {
+  assert((Size >= sizeof(MDNode)) && "Insufficient size to operator new!");
+  // MDNode wants to construct its ancillary MDOperands ** BEFORE **
+  // itself.
   size_t OpSize = NumOps * sizeof(MDOperand);
   // uint64_t is the most aligned type we need support (ensured by static_assert
   // above)
   OpSize = RoundUpToAlignment(OpSize, llvm::alignOf<uint64_t>());
-  void *Ptr = reinterpret_cast<char *>(::operator new(OpSize + Size)) + OpSize;
-  MDOperand *O = static_cast<MDOperand *>(Ptr);
-  for (MDOperand *E = O - NumOps; O != E; --O)
-    (void)new (O - 1) MDOperand;
-  return Ptr;
+  std::size_t RSize = Size + OpSize + sizeof(Metadata) + sizeof(uintptr_t);
+  RSize = RoundUpToAlignment(RSize, llvm::alignOf<uint64_t>());
+  std::size_t Alignment = llvm::alignOf<uint64_t>();
+
+  void *P;
+#if defined(_MSC_VER)
+  P = _aligned_malloc(RSize, Alignment);
+  assert(P && "_aligned_malloc failed!");
+  if (!P) return 0;
+#else
+  int R = posix_memalign(&P, Alignment, RSize);
+  assert((R == 0) && "posix_memalign failed!");
+  if (R != 0) return 0;
+#endif
+
+  (void) std::memset(P, 0, RSize);
+  unsigned char *UC = static_cast<unsigned char*>(P);
+  MDNode *MN = reinterpret_cast<MDNode*>((UC + RSize) - Size);
+
+  MDOperand *O = reinterpret_cast<MDOperand*>(MN);
+  MDOperand *MO;
+
+  for (MDOperand *E = O - NumOps; O != E; --O) {
+    MO = new (O - 1) MDOperand();
+    assert(MO && "MDOperand placement new failed!");
+  }
+
+  // We store the address of the aligned allocated buffer
+  // in the last extra element of the buffer. This address
+  // will be used by the corresponding operator delete to
+  // free the correct address.
+  uintptr_t *U = reinterpret_cast<uintptr_t*>(O - 1);
+  *U = reinterpret_cast<uintptr_t>(P);
+  return MN;
+}
+
+void MDNode::operator delete(void *Mem) throw() {
+  MDNode *MN = reinterpret_cast<MDNode *>(Mem);
+  Metadata *MTD = static_cast<Metadata*>(MN);
+  std::size_t OSize = MN->NumOperands * sizeof(MDOperand);
+  OSize = RoundUpToAlignment(OSize, llvm::alignOf<uint64_t>());
+  MDOperand *O = static_cast<MDOperand *>(Mem);
+
+  for (MDOperand *E = O - MN->NumOperands; O != E; --O) {
+    MDOperand *MO = (O - 1);
+    MO->~MDOperand();
 }
 
-void MDNode::operator delete(void *Mem) {
-  MDNode *N = static_cast<MDNode *>(Mem);
-  size_t OpSize = N->NumOperands * sizeof(MDOperand);
-  OpSize = RoundUpToAlignment(OpSize, llvm::alignOf<uint64_t>());
+  MTD->~Metadata();
+  MN->~MDNode();
 
-  MDOperand *O = static_cast<MDOperand *>(Mem);
-  for (MDOperand *E = O - N->NumOperands; O != E; --O)
-    (O - 1)->~MDOperand();
-  ::operator delete(reinterpret_cast<char *>(Mem) - OpSize);
+  // This is the address of the allocated buffer in the
+  // extra buffer space allocated by operator new.
+  uintptr_t *U = reinterpret_cast<uintptr_t*>(O - 1);
+  std::free(reinterpret_cast<void*>(*U));
 }
 
-MDNode::MDNode(LLVMContext &Context, unsigned ID, StorageType Storage,
+MDNode::MDNode(LLVMContext &Ctx, unsigned ID, StorageType Storage,
                ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2)
     : Metadata(ID, Storage), NumOperands(Ops1.size() + Ops2.size()),
-      NumUnresolved(0), Context(Context) {
+  NumUnresolved(0U), Context(Ctx) {
   unsigned Op = 0;
   for (Metadata *MD : Ops1)
     setOperand(Op++, MD);
@@ -692,6 +734,9 @@
     llvm_unreachable("Invalid subclass of MDNode");
 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
   case CLASS##Kind:                                                            \
+    static_assert(llvm::AlignOf<uint64_t>::Alignment >=             \
+        llvm::AlignOf<CLASS>::Alignment,                            \
+        "Insufficient alignment for objects prepended to " #CLASS); \
     delete cast<CLASS>(this);                                                  \
     break;
 #include "llvm/IR/Metadata.def"
@@ -729,6 +774,9 @@
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   case CLASS##Kind: {                                                          \
     CLASS *SubclassThis = cast<CLASS>(this);                                   \
+    static_assert(llvm::AlignOf<uint64_t>::Alignment >=             \
+        llvm::AlignOf<CLASS>::Alignment,                            \
+        "Insufficient alignment for objects prepended to " #CLASS); \
     std::integral_constant<bool, HasCachedHash<CLASS>::value>                  \
         ShouldRecalculateHash;                                                 \
     dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash);              \
@@ -744,6 +792,9 @@
     llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   case CLASS##Kind:                                                            \
+    static_assert(llvm::AlignOf<uint64_t>::Alignment >=             \
+        llvm::AlignOf<CLASS>::Alignment,                            \
+        "Insufficient alignment for objects prepended to " #CLASS); \
     getContext().pImpl->CLASS##s.erase(cast<CLASS>(this));                     \
     break;
 #include "llvm/IR/Metadata.def"
@@ -784,6 +835,9 @@
     llvm_unreachable("Invalid subclass of MDNode");
 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
   case CLASS##Kind: {                                                          \
+    static_assert(llvm::AlignOf<uint64_t>::Alignment >=             \
+        llvm::AlignOf<CLASS>::Alignment,                            \
+        "Insufficient alignment for objects prepended to " #CLASS); \
     std::integral_constant<bool, HasCachedHash<CLASS>::value> ShouldResetHash; \
     dispatchResetHash(cast<CLASS>(this), ShouldResetHash);                     \
     break;                                                                     \
@@ -1007,6 +1061,88 @@
 }
 
 //===----------------------------------------------------------------------===//
+// MDTupel implementation.
+//
+void *MDTuple::operator new(size_t Size, unsigned NumOps) throw() {
+  assert((Size >= sizeof(MDTuple)) && "Insufficient size to operator new!");
+
+  std::size_t OSize = NumOps * sizeof(MDOperand);
+  OSize = RoundUpToAlignment(OSize, llvm::alignOf<uint64_t>());
+
+  // Allocate extra space for an uintptr_t at the beginning of the
+  // buffer.  This uintptr_t is where we will store the address of
+  // the memory-aligned storage buffer. It will be plasced immediately
+  // after the last MDOperand.
+  // This address will be computed by the matching operator delete.
+  // The total amount of space allocated must include the Size
+  // parameter passed in. This parameter value is not necessarily
+  // equal to sizeof(MDTuple), it can be greater.
+  std::size_t RSize = Size + OSize + sizeof(MDTuple) + sizeof(uintptr_t);
+  RSize = RoundUpToAlignment(RSize, llvm::alignOf<uint64_t>());
+  std::size_t Alignment = llvm::alignOf<uint64_t>();
+
+  void *P;
+#if defined(_MSC_VER)
+  P = _aligned_malloc(RSize, Alignment);
+  assert(P && "_aligned_malloc failed!");
+  if (!P) return 0;
+#else
+  int R = posix_memalign(&P, Alignment, RSize);
+  assert((R == 0) && "posix_memalign failed!");
+  if (R != 0) return 0;
+#endif
+
+  (void) std::memset(P, 0, RSize);
+
+  // Set a valid pointer to the address which will be returned
+  // by this operator. This will be a pointer to a MDTuple.
+  unsigned char *UC = static_cast<unsigned char*>(P);
+  MDTuple *MDT = reinterpret_cast<MDTuple*>((UC + RSize) - Size);
+  MDNode *MN = static_cast<MDNode*>(MDT);
+
+  MDOperand *O = reinterpret_cast<MDOperand*>(MN);
+  MDOperand *MO;
+
+  for (MDOperand *E = O - NumOps; O != E; --O) {
+    MO = new (O - 1) MDOperand();
+    assert(MO && "MDOperand placement new failed!");
+  }
+
+  // We store the address of the aligned allocated buffer
+  // in the last extra element of the buffer. This address
+  // will be used by the corresponding operator delete to
+  // free the correct address.
+  uintptr_t *U = reinterpret_cast<uintptr_t*>(O - 1);
+  *U = reinterpret_cast<uintptr_t>(P);
+  return MDT;
+}
+
+void MDTuple::operator delete(void *Mem) throw() {
+  MDTuple *MDT = reinterpret_cast<MDTuple*>(Mem);
+  // UniquableMDNode *UMN = static_cast<UniquableMDNode*>(MDT);
+  MDNode *MN = static_cast<MDNode*>(MDT);
+  unsigned NumOperands = MN->getNumOperands();
+
+  std::size_t OSize = NumOperands * sizeof(MDOperand);
+  OSize = RoundUpToAlignment(OSize, llvm::alignOf<uint64_t>());
+
+  MDOperand *O =
+    reinterpret_cast<MDOperand*>(reinterpret_cast<void*>(MN));
+  for (MDOperand *E = O - NumOperands; O != E; --O) {
+    MDOperand *MO = (O - 1);
+    MO->~MDOperand();
+  }
+
+  // This is teh address of the allocated buffer in the
+  // extra space allocated by operator new in RSize.
+  uintptr_t *U = reinterpret_cast<uintptr_t*>(O - 1);
+
+  // UMN->~UniquableMDNode();
+  MDT->~MDTuple();
+  std::free(reinterpret_cast<void*>(*U));
+}
+
+//===----------------------------------------------------------------------===//
 // NamedMDNode implementation.
 //