Subzero. Fixes memory leaks.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- 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 aspects of the compilation that persist across
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALCONTEXT_H
 #define SUBZERO_SRC_ICEGLOBALCONTEXT_H
 
 #include <array>
+#include <functional>
 #include <mutex>
 #include <thread>
+#include <type_traits>
+#include <vector>
 
 #include "IceDefs.h"
 #include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
 #include "IceThreading.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 #include "IceUtils.h"
 
@@ skipping 172 matching lines @@
   ConstantList getConstantPool(Type Ty);
   // Returns a copy of the list of external symbols.
   ConstantList getConstantExternSyms();
 
   const ClFlags &getFlags() const { return Flags; }
 
   bool isIRGenerationDisabled() const {
     return getFlags().getDisableIRGeneration();
   }
 
-  // Allocate data of type T using the global allocator.
-  template <typename T> T *allocate() { return getAllocator()->Allocate<T>(); }
+  // Allocate data of type T using the global allocator. We allow entites

[Jim Stichnoth, 2015/06/19 23:09:25]

entities

+  // allocated from this global allocator to be either trivially and

[Jim Stichnoth, 2015/06/19 23:09:25]

either ... or

[John, 2015/06/20 00:10:33]

Done.

+  // non-trivially destructible. We optimize the case when T is trivially
+  // destructible by not registering a destructor. Destructors will be invoked
+  // during GlobalContext destruction in the reverse object creation order.
+  template <typename T>
+  typename std::enable_if<std::is_trivially_destructible<T>::value, T>::type *

[Jim Stichnoth, 2015/06/19 23:09:25]

This is a cool trick, but I feel that the user might unknowingly allocate lots
of objects with nontrivial dtors.

What do you think of calling them something like allocate<>() and
allocateWithDtor<>()?  This forces the user to make a conscious choice.

Since misuse would cause such horrible error messages, maybe use static_assert
instead of enable_if<>?

[John, 2015/06/20 00:10:33]

And that's fine. This allocator, essentially, "replaces" the heap so that we
don't have to keep track of memory management (which is bad in my opinion, but
we already have allocators, so...)
This makes sense in the CfgLocalAllocator as those objects need to be deleted
fast. This global pool should simply run destructors when memory is being
reclaimed. If you don't want you type do have a destructor, you're better off
saying

~Foo() = delete

This way, the compiler will yell if you try to destroy the object (including
implicit stack allocations when the go out of scope, and unique_ptrs.)
It would not. clang++ says "something something std::enable_if<>", and it
highlights enable_if. clang++'s gone a long way since g++ cryptic error
messages. :)

[Jim Stichnoth, 2015/06/21 00:15:48]

OK, I buy that.

+  allocate() {
+    return getAllocator()->Allocate<T>();
+  }
+
+  template <typename T>
+  typename std::enable_if<!std::is_trivially_destructible<T>::value, T>::type *
+  allocate() {
+    T *Ret = getAllocator()->Allocate<T>();
+    getDestructors()->emplace_back([Ret]() { Ret->~T(); });
+    return Ret;
+  }
 
   const Intrinsics &getIntrinsicsInfo() const { return IntrinsicsInfo; }
 
   // TODO(wala,stichnot): Make the RNG play nicely with multithreaded
   // translation.
   RandomNumberGenerator &getRNG() { return RNG; }
 
   ELFObjectWriter *getObjectWriter() const { return ObjectWriter.get(); }
 
   // Reset stats at the beginning of a function.
@@ skipping 150 matching lines @@
 
   // Emitter thread startup routine.
   void emitterWrapper(ThreadContext *MyTLS) {
     ICE_TLS_SET_FIELD(TLS, MyTLS);
     emitItems();
   }
   // Emit functions and global initializers from the emitter queue
   // until the queue is empty.
   void emitItems();
 
-  // Uses DataLowering to lower Globals. As a side effect, clears the Globals
-  // array.
+  // Uses DataLowering to lower Globals. Side effects:
+  //  - discards the initializer list for the global variable in Globals.
+  //  - clears the Globals array.
   void lowerGlobals(const IceString &SectionSuffix);
 
   // Lowers the profile information.
   void lowerProfileData();
 
   // Utility function to match a symbol name against a match string.
   // This is used in a few cases where we want to take some action on
   // a particular function or symbol based on a command-line argument,
   // such as changing the verbose level for a particular function.  An
   // empty Match argument means match everything.  Returns true if
   // there is a match.
   static bool matchSymbolName(const IceString &SymbolName,
                               const IceString &Match) {
     return Match.empty() || Match == SymbolName;
   }
 
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
+  // Destructors collaborate with Allocator
   ICE_CACHELINE_BOUNDARY;
   // Managed by getAllocator()
   GlobalLockType AllocLock;
   ArenaAllocator<> Allocator;
 
   ICE_CACHELINE_BOUNDARY;
+  // Managed by getDestructors()
+  typedef std::vector<std::function<void()>> DestructorArray;
+  GlobalLockType DestructorsLock;
+  DestructorArray Destructors;
+
+  ICE_CACHELINE_BOUNDARY;
   // Managed by getConstantPool()
   GlobalLockType ConstPoolLock;
   std::unique_ptr<ConstantPool> ConstPool;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getErrorStatus()
   GlobalLockType ErrorStatusLock;
   ErrorCode ErrorStatus;
 
   ICE_CACHELINE_BOUNDARY;
@@ skipping 27 matching lines @@
   // emitItems(), or in IceCompiler::run before the compilation is over.)
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<TargetDataLowering> DataLowering;
   // If !HasEmittedCode, SubZero will accumulate all Globals (which are "true"
   // program global variables) until the first code WorkItem is seen.
   // TODO(jpp): move to EmitterContext.
   bool HasSeenCode;
   // TODO(jpp): move to EmitterContext.
   VariableDeclarationList Globals;
   // TODO(jpp): move to EmitterContext.
-  std::unique_ptr<VariableDeclaration> ProfileBlockInfoVarDecl;
+  VariableDeclaration *ProfileBlockInfoVarDecl;
 
   LockedPtr<ArenaAllocator<>> getAllocator() {
     return LockedPtr<ArenaAllocator<>>(&Allocator, &AllocLock);
   }
   LockedPtr<ConstantPool> getConstPool() {
     return LockedPtr<ConstantPool>(ConstPool.get(), &ConstPoolLock);
   }
   LockedPtr<CodeStats> getStatsCumulative() {
     return LockedPtr<CodeStats>(&StatsCumulative, &StatsLock);
   }
   LockedPtr<TimerList> getTimers() {
     return LockedPtr<TimerList>(&Timers, &TimerLock);
   }
+  LockedPtr<DestructorArray> getDestructors() {
+    return LockedPtr<DestructorArray>(&Destructors, &DestructorsLock);
+  }
 
   void accumulateGlobals(std::unique_ptr<VariableDeclarationList> Globls) {
     if (Globls != nullptr)
       Globals.insert(Globals.end(), Globls->begin(), Globls->end());
   }
 
   void lowerGlobalsIfNoCodeHasBeenSeen() {
     if (HasSeenCode)
       return;
     constexpr char NoSuffix[] = "";
@@ skipping 65 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H