Subzero. Fixes memory leaks.

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declaraions -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares various useful types and classes that have
@@ skipping 75 matching lines @@
 inline bool operator==(const CfgLocalAllocator<T> &,
                        const CfgLocalAllocator<U> &) {
   return true;
 }
 template <typename T, typename U>
 inline bool operator!=(const CfgLocalAllocator<T> &,
                        const CfgLocalAllocator<U> &) {
   return false;
 }
 
+// makeUnique should be used when memory is expected to be allocated from the
+// heap (as opposed to allocated from some Allocator.) It is intended to be used
+// instead of new.
+//
+// The expected usage is as follows
+//
+// class MyClass {
+// public:
+//   static std::unique_ptr<MyClass> create(<ctor_args>) {
+//     return makeUnique<MyClass>(<ctor_args>);
+//   }
+//
+// private:
+//   ENABLE_MAKE_UNIQUE;
+//
+//   MyClass(<ctor_args>) ...
+// }
+//
+// ENABLE_MAKE_UNIQUE is a trick that is necessary if MyClass' ctor is private.
+// Private ctors are highly encouraged when you're writing a class that you'd
+// like to have allocated with makeUnique as it would prevent users from
+// declaring stack allocated variables.
+namespace Internal {
+struct MakeUniqueEnabler {
+  template <class T, class... Args>
+  static std::unique_ptr<T> create(Args &&... TheArgs) {
+    std::unique_ptr<T> Unique(new T(std::forward<Args>(TheArgs)...));
+    return Unique;
+  }
+};
+} // end of namespace Internal
+
+template <class T, class... Args>
+static std::unique_ptr<T> makeUnique(Args &&... TheArgs) {
+  return ::Ice::Internal::MakeUniqueEnabler::create<T>(
+      std::forward<Args>(TheArgs)...);
+}
+
+#define ENABLE_MAKE_UNIQUE friend struct ::Ice::Internal::MakeUniqueEnabler
+
 typedef std::string IceString;
 typedef llvm::ilist<Inst> InstList;
 // Ideally PhiList would be llvm::ilist<InstPhi>, and similar for
 // AssignList, but this runs into issues with SFINAE.
 typedef InstList PhiList;
 typedef InstList AssignList;
 // VarList and NodeList are arena-allocated from the Cfg's allocator.
 typedef std::vector<Variable *, CfgLocalAllocator<Variable *>> VarList;
 typedef std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>> NodeList;
 typedef std::vector<Constant *> ConstantList;
@@ skipping 115 matching lines @@
   return llvm::make_range(Container.rbegin(), Container.rend());
 }
 template <typename T>
 llvm::iterator_range<typename T::reverse_iterator> reverse_range(T &Container) {
   return llvm::make_range(Container.rbegin(), Container.rend());
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H