Subzero. Allocate global initializers from a dedicated arena.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 274 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::createExternal(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");
-
   TargetLowering::staticInit(this);
 }
 
 void GlobalContext::translateFunctions() {
   TimerMarker Timer(TimerStack::TT_translateFunctions, this);
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     CfgLocalAllocatorScope _(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
@@ skipping 74 matching lines @@
       getErrorStatus()->assign(EC_Translation);
     }
     TargetHeaderLowering::createLowering(this)->lower();
   }
 }
 
 void GlobalContext::lowerConstants() { DataLowering->lowerConstants(); }
 
 void GlobalContext::lowerJumpTables() { DataLowering->lowerJumpTables(); }
 
-void GlobalContext::addBlockInfoPtrs(VariableDeclaration *ProfileBlockInfo) {
-  for (const VariableDeclaration *Global : Globals) {
+void GlobalContext::saveBlockInfoPtrs() {
+  for (VariableDeclaration *Global : Globals) {
     if (Cfg::isProfileGlobal(*Global)) {
-      constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
-      ProfileBlockInfo->addInitializer(
-          VariableDeclaration::RelocInitializer::create(
-              Global,
-              {RelocOffset::create(this, BlockExecutionCounterOffset)}));
+      ProfileBlockInfos.push_back(Global);
     }
   }
 }
 
 void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
   const bool DumpGlobalVariables = BuildDefs::dump() &&
                                    (Flags.getVerbose() & IceV_GlobalInit) &&
                                    Flags.getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
-  addBlockInfoPtrs(ProfileBlockInfoVarDecl);
+  saveBlockInfoPtrs();
   // If we need to shuffle the layout of global variables, shuffle them now.
   if (getFlags().shouldReorderGlobalVariables()) {
     // Create a random number generator for global variable reordering.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_GlobalVariableReordering);
     RandomShuffle(Globals.begin(), Globals.end(),
                   [&RNG](int N) { return (uint32_t)RNG.next(N); });
   }
   DataLowering->lowerGlobals(Globals, SectionSuffix);
-  for (VariableDeclaration *Var : Globals) {
-    Var->discardInitializers();
+  if (ProfileBlockInfos.empty() && DisposeGlobalVariablesAfterLowering) {
+    Globals.clearAndPurge();
+  } else {
+    Globals.clear();
   }
-  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);
+  assert(ProfileBlockInfoVarDecl == nullptr);
+
+  auto GlobalVariablePool = getInitializerAllocator();
+  ProfileBlockInfoVarDecl =
+      VariableDeclaration::createExternal(GlobalVariablePool.get());
+  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");
+
+  for (const VariableDeclaration *PBI : ProfileBlockInfos) {
+    if (Cfg::isProfileGlobal(*PBI)) {
+      constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
+      ProfileBlockInfoVarDecl->addInitializer(
+          VariableDeclaration::RelocInitializer::create(
+              GlobalVariablePool.get(), PBI,
+              {RelocOffset::create(this, BlockExecutionCounterOffset)}));
+    }
+  }
+
   // 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(
-      VariableDeclaration::ZeroInitializer::create(Sizeof64BitNullPtr));
+      VariableDeclaration::ZeroInitializer::create(GlobalVariablePool.get(),
+                                                   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 447 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