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

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
@@ skipping 285 matching lines @@
   // the work queue is currently empty.  Returns nullptr if there is
   // no more work - the queue is empty and either end() has been
   // called or the Sequential flag was set.
   std::unique_ptr<Cfg> optQueueBlockingPop();
   // Notifies that no more work will be added to the work queue.
   void optQueueNotifyEnd() { OptQ.notifyEnd(); }
 
   // Emit file header for output file.
   void emitFileHeader();
 
+  void lowerConstants();
+
   void emitQueueBlockingPush(EmitterWorkItem *Item);
   EmitterWorkItem *emitQueueBlockingPop();
   void emitQueueNotifyEnd() { EmitQ.notifyEnd(); }
 
   void initParserThread() {
     ThreadContext *Tls = new ThreadContext();
     auto Timers = getTimers();
     Timers->initInto(Tls->Timers);
     AllThreadContexts.push_back(Tls);
     ICE_TLS_SET_FIELD(TLS, Tls);
@@ skipping 57 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.
+  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;
   }
@@ skipping 35 matching lines @@
   Ostream *StrError; // Stream for logging errors.
 
   ICE_CACHELINE_BOUNDARY;
 
   Intrinsics IntrinsicsInfo;
   const ClFlags &Flags;
   RandomNumberGenerator RNG; // TODO(stichnot): Move into Cfg.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
   BoundedProducerConsumerQueue<Cfg> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
+  // DataLowering is only ever used by a single thread at a time (either in
+  // emitItems(), or in IceCompiler::run before the compilation is over.)
+  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.
+  bool HasSeenCode;
+  VariableDeclarationList Globals;
+  std::unique_ptr<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);
   }
 
+  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[] = "";
+    lowerGlobals(NoSuffix);
+    HasSeenCode = true;
+  }
+
   llvm::SmallVector<ThreadContext *, 128> AllThreadContexts;
   llvm::SmallVector<std::thread, 128> TranslationThreads;
   llvm::SmallVector<std::thread, 128> EmitterThreads;
   // Each thread has its own TLS pointer which is also held in
   // AllThreadContexts.
   ICE_TLS_DECLARE_FIELD(ThreadContext *, TLS);
 
   // Private helpers for mangleName()
   typedef llvm::SmallVector<char, 32> ManglerVector;
   void incrementSubstitutions(ManglerVector &OldName) const;
@@ skipping 51 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