Subzero. Fixes memory leaks.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 206 matching lines @@
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
       StrEmit(OsEmit), StrError(OsError), Flags(Flags),
       RNG(Flags.getRandomSeed()), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)),
-      HasSeenCode(false),
-      ProfileBlockInfoVarDecl(VariableDeclaration::create()) {
+      HasSeenCode(false) {
   assert(OsDump && "OsDump is not defined for GlobalContext");
   assert(OsEmit && "OsEmit is not defined for GlobalContext");
   assert(OsError && "OsError is not defined for GlobalContext");
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // free.
   GlobalContext::TlsInit();
   Cfg::TlsInit();
   // Create a new ThreadContext for the current thread.  No need to
@@ skipping 11 matching lines @@
   }
   Timers.initInto(MyTLS->Timers);
   switch (Flags.getOutFileType()) {
   case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
   case FT_Asm:
   case FT_Iasm:
     break;
   }
+
+  // ProfileBlockInfoVarDecl is initialized here because it takes this as a
+  // parameter -- we want to
+  // ensure that at least this' member variables are initialized.
+  ProfileBlockInfoVarDecl = VariableDeclaration::create(this);
   ProfileBlockInfoVarDecl->setAlignment(typeWidthInBytes(IceType_i64));
   ProfileBlockInfoVarDecl->setIsConstant(true);
 
   // Note: if you change this symbol, make sure to update
   // runtime/szrt_profiler.c as well.
   ProfileBlockInfoVarDecl->setName("__Sz_block_profile_info");
   ProfileBlockInfoVarDecl->setSuppressMangling();
   ProfileBlockInfoVarDecl->setLinkage(llvm::GlobalValue::ExternalLinkage);
 }
 
@@ skipping 62 matching lines @@
 }
 
 namespace {
 
 void addBlockInfoPtrs(const VariableDeclarationList &Globals,
                       VariableDeclaration *ProfileBlockInfo) {
   for (const VariableDeclaration *Global : Globals) {
     if (Cfg::isProfileGlobal(*Global)) {
       constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
       ProfileBlockInfo->addInitializer(
-          new VariableDeclaration::RelocInitializer(
+          VariableDeclaration::RelocInitializer::create(
               Global, BlockExecutionCounterOffset));
     }
   }
 }
 
 // Ensure Pending is large enough that Pending[Index] is valid.
 void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
   if (Index >= Pending.size())
     Pending.resize(Index + 1);
 }
 
 } // end of anonymous namespace
 
 void GlobalContext::emitFileHeader() {
   TimerMarker T1(Ice::TimerStack::TT_emit, this);
   if (getFlags().getOutFileType() == FT_Elf) {
     getObjectWriter()->writeInitialELFHeader();
   } else {
     if (!ALLOW_DUMP)
       llvm::report_fatal_error("emitFileHeader for non-ELF");
     TargetHeaderLowering::createLowering(this)->lower();
   }
 }
 
-void GlobalContext::lowerConstants() {
-  DataLowering->lowerConstants();
-}
+void GlobalContext::lowerConstants() { DataLowering->lowerConstants(); }
 
 void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
   const bool DumpGlobalVariables =
       ALLOW_DUMP && Flags.getVerbose() && Flags.getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(this, Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
-  addBlockInfoPtrs(Globals, ProfileBlockInfoVarDecl.get());
+  addBlockInfoPtrs(Globals, ProfileBlockInfoVarDecl);
   DataLowering->lowerGlobals(Globals, SectionSuffix);
+  for (VariableDeclaration *Var : Globals) {
+    Var->discardInitializers();
+  }
   Globals.clear();
 }
 
 void GlobalContext::lowerProfileData() {
+  // ProfileBlockInfoVarDecl is initialized in the constructor, and will only
+  // ever be nullptr after this method completes. This assertion is a convoluted
+  // way of ensuring lowerProfileData is invoked a single time.
+  assert(ProfileBlockInfoVarDecl != nullptr);
   // This adds a 64-bit sentinel entry to the end of our array. For 32-bit
   // architectures this will waste 4 bytes.
   const SizeT Sizeof64BitNullPtr = typeWidthInBytes(IceType_i64);
   ProfileBlockInfoVarDecl->addInitializer(
-      new VariableDeclaration::ZeroInitializer(Sizeof64BitNullPtr));
-  Globals.push_back(ProfileBlockInfoVarDecl.get());
+      VariableDeclaration::ZeroInitializer::create(Sizeof64BitNullPtr));
+  Globals.push_back(ProfileBlockInfoVarDecl);
   constexpr char ProfileDataSection[] = "$sz_profiler$";
   lowerGlobals(ProfileDataSection);
+  ProfileBlockInfoVarDecl = nullptr;
 }
 
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
   // work items.  When we're ready for the next item, we first check
   // whether it's in the Pending list.  If not, we take an item from
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
@@ skipping 228 matching lines @@
     return NewName.data();
   }
 
   // Transform bar ==> Prefixbar
   //                   ^^^^^^
   return TestPrefix + Name;
 }
 
 GlobalContext::~GlobalContext() {
   llvm::DeleteContainerPointers(AllThreadContexts);
+  LockedPtr<DestructorArray> Dtors = getDestructors();
+  // Destructors are invoked in the opposite object construction order.
+  for (auto DtorIter = Dtors->crbegin(); DtorIter != Dtors->crend();
+       ++DtorIter) {
+    (*DtorIter)();
+  }
 }
 
 // TODO(stichnot): Consider adding thread-local caches of constant
 // pool entries to reduce contention.
 
 // All locking is done by the getConstantInt[0-9]+() target function.
 Constant *GlobalContext::getConstantInt(Type Ty, int64_t Value) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1(Value);
@@ skipping 237 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice