Subzero: Fixed deadlock with _start but no globals

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 464 matching lines @@
 
   void setDisposeGlobalVariablesAfterLowering(bool Value) {
     DisposeGlobalVariablesAfterLowering = Value;
   }
   /// @}
 
   LockedPtr<StringPool> getStrings() const {
     return LockedPtr<StringPool>(Strings.get(), &StringsLock);
   }
 
+  LockedPtr<VariableDeclarationList> getGlobals() {
+    return LockedPtr<VariableDeclarationList>(&Globals, &InitAllocLock);
+  }
+
+  bool getGlobalsReceived() { return GlobalsReceived; }
+
   /// Number of function blocks that can be queued before waiting for
   /// translation
   /// threads to consume.
   static constexpr size_t MaxOptQSize = 1 << 16;
 
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
   // Destructors collaborate with Allocator
   ICE_CACHELINE_BOUNDARY;
   // Managed by getAllocator()
   mutable GlobalLockType AllocLock;
   ArenaAllocator Allocator;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getInitializerAllocator()
   mutable GlobalLockType InitAllocLock;
   VariableDeclarationList Globals;
+  std::atomic<bool> GlobalsReceived;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getDestructors()
   using DestructorArray = std::vector<std::function<void()>>;
   mutable GlobalLockType DestructorsLock;
   DestructorArray Destructors;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getStrings()
   mutable GlobalLockType StringsLock;
@@ skipping 92 matching lines @@
     return LockedPtr<TimerList>(&Timers, &TimerLock);
   }
   LockedPtr<DestructorArray> getDestructors() {
     return LockedPtr<DestructorArray>(&Destructors, &DestructorsLock);
   }
 
   void accumulateGlobals(std::unique_ptr<VariableDeclarationList> Globls) {
     LockedPtr<VariableDeclarationList> _(&Globals, &InitAllocLock);
     if (Globls != nullptr) {
       Globals.merge(Globls.get());
+      GlobalsReceived = true;
     }
   }
 
   void lowerGlobalsIfNoCodeHasBeenSeen() {
     if (HasSeenCode)
       return;
     constexpr char NoSuffix[] = "";
     lowerGlobals(NoSuffix);
     HasSeenCode = true;
   }
@@ skipping 67 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