Fix a bug that would cause subzero to fail when --threads=0.

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 204 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()) {
+      EmitQ(/*Sequential=*/Flags.isSequential()),
+      DataLowering(TargetDataLowering::createLowering(this)),
+      HasSeenCode(false),
+      ProfileBlockInfoVarDecl(VariableDeclaration::create()) {
   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->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);
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
@@ skipping 48 matching lines @@
     }
     Cfg::setCurrentCfg(nullptr);
     assert(Item);
     emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
-// Adds an array of pointers to all the profiler-generated globals. The
-// __Sz_profile_summary function iterates over this array for printing the
-// profiling counters.
-VariableDeclaration *blockProfileInfo(const VariableDeclarationList &Globals) {
-  auto *Var = VariableDeclaration::create();
-  Var->setAlignment(typeWidthInBytes(IceType_i64));
-  Var->setIsConstant(true);
-
-  // Note: if you change this symbol, make sure to update
-  // runtime/szrt_profiler.c as well.
-  Var->setName("__Sz_block_profile_info");
-  Var->setSuppressMangling();
-  Var->setLinkage(llvm::GlobalValue::ExternalLinkage);
+void addBlockInfoPtrs(const VariableDeclarationList &Globals,
+                      VariableDeclaration *ProfileBlockInfo) {
   for (const VariableDeclaration *Global : Globals) {
     if (Cfg::isProfileGlobal(*Global)) {
       constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
-      Var->addInitializer(new VariableDeclaration::RelocInitializer(
-          Global, BlockExecutionCounterOffset));
+      ProfileBlockInfo->addInitializer(
+          new VariableDeclaration::RelocInitializer(
+              Global, 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);
-  Var->addInitializer(
-      new VariableDeclaration::ZeroInitializer(Sizeof64BitNullPtr));
-
-  return Var;
-}
-
-void addBlockProfileInfoArrayToGlobals(VariableDeclarationList *Globals) {
-  // Purposefully create the Var temp to prevent bugs in case the compiler
-  // reorders instructions in a way that Globals is extended before the call
-  // to profileInfoArray.
-  VariableDeclaration *Var = blockProfileInfo(*Globals);
-  Globals->push_back(Var);
-}
-
-void lowerGlobals(GlobalContext *Ctx,
-                  std::unique_ptr<VariableDeclarationList> VariableDeclarations,
-                  TargetDataLowering *DataLowering) {
-  TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
-  const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getFlags().getVerbose() &&
-                                   Ctx->getFlags().getVerboseFocusOn().empty();
-  if (DumpGlobalVariables) {
-    OstreamLocker L(Ctx);
-    Ostream &Stream = Ctx->getStrDump();
-    for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
-      Global->dump(Ctx, Stream);
-    }
-  }
-  if (Ctx->getFlags().getDisableTranslation())
-    return;
-
-  // There should be no need to emit the block_profile_info array if profiling
-  // is disabled. In practice, given that szrt_profiler.o will always be
-  // embedded in the application, we need to add it. In a non-profiled build
-  // this array will only contain the nullptr terminator.
-  addBlockProfileInfoArrayToGlobals(VariableDeclarations.get());
-
-  DataLowering->lowerGlobals(std::move(VariableDeclarations));
 }
 
 // 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);
 }
 
-void addAllIfNotNull(std::unique_ptr<VariableDeclarationList> src,
-                     VariableDeclarationList *dst) {
-  if (src != nullptr) {
-    dst->insert(dst->end(), src->begin(), src->end());
-  }
-}
-
 } // 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::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());
+  DataLowering->lowerGlobals(Globals, SectionSuffix);
+  Globals.clear();
+}
+
+void GlobalContext::lowerProfileData() {
+  // 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());
+  constexpr char ProfileDataSection[] = "$sz_profiler$";
+  lowerGlobals(ProfileDataSection);
+}
+
 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.
-  std::unique_ptr<VariableDeclarationList> GlobalInits(
-      new VariableDeclarationList());
   std::vector<EmitterWorkItem *> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   while (true) {
     resizePending(Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
     EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
     if (RawItem == nullptr)
       RawItem = emitQueueBlockingPop();
     if (RawItem == nullptr)
       break;
     uint32_t ItemSeq = RawItem->getSequenceNumber();
     if (Threaded && ItemSeq != DesiredSequenceNumber) {
       resizePending(Pending, ItemSeq);
       Pending[ItemSeq] = RawItem;
       continue;
     }
 
     std::unique_ptr<EmitterWorkItem> Item(RawItem);
     ++DesiredSequenceNumber;
     switch (Item->getKind()) {
     case EmitterWorkItem::WI_Nop:
       break;
     case EmitterWorkItem::WI_GlobalInits: {
-      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
+      accumulateGlobals(Item->getGlobalInits());
     } break;
     case EmitterWorkItem::WI_Asm: {
-      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
+      lowerGlobalsIfNoCodeHasBeenSeen();
+      accumulateGlobals(Item->getGlobalInits());
+
       std::unique_ptr<Assembler> Asm = Item->getAsm();
       Asm->alignFunction();
       IceString MangledName = mangleName(Asm->getFunctionName());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
         getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
                                              Asm.get());
         break;
       case FT_Iasm: {
         OstreamLocker L(this);
         Cfg::emitTextHeader(MangledName, this, Asm.get());
         Asm->emitIASBytes(this);
       } break;
       case FT_Asm:
         llvm::report_fatal_error("Unexpected FT_Asm");
         break;
       }
     } break;
     case EmitterWorkItem::WI_Cfg: {
       if (!ALLOW_DUMP)
         llvm::report_fatal_error("WI_Cfg work item created inappropriately");
-
-      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
+      lowerGlobalsIfNoCodeHasBeenSeen();
+      accumulateGlobals(Item->getGlobalInits());
 
       assert(getFlags().getOutFileType() == FT_Asm);
       std::unique_ptr<Cfg> Func = Item->getCfg();
       // Unfortunately, we have to temporarily install the Cfg in TLS
       // because Variable::asType() uses the allocator to create the
       // differently-typed copy.
       Cfg::setCurrentCfg(Func.get());
       Func->emit();
       Cfg::setCurrentCfg(nullptr);
       dumpStats(Func->getFunctionName());
     } break;
     }
   }
 
-  lowerGlobals(this, std::move(GlobalInits),
-               TargetDataLowering::createLowering(this).get());
+  // In case there are no code to be generated, we invoke the conditional
+  // lowerGlobals again -- this is a no-op if code has been emitted.
+  lowerGlobalsIfNoCodeHasBeenSeen();
 }
 
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
@@ skipping 406 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