Do not inline GlobalContext TLS methods.

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 354 matching lines @@
     auto *Revision = VariableDeclaration::create(&Globals, true);
     Revision->setName(this, "__Sz_revision");
     Revision->setIsConstant(true);
     const char *RevisionString = getSubzeroRevision();
     Revision->addInitializer(VariableDeclaration::DataInitializer::create(
         &Globals, RevisionString, 1 + strlen(RevisionString)));
     Globals.push_back(Revision);
   }
 }
 
+void GlobalContext::translateFunctionsWrapper(ThreadContext *MyTLS) {
+  ICE_TLS_SET_FIELD(TLS, MyTLS);
+  translateFunctions();
+}
+
 void GlobalContext::translateFunctions() {
   TimerMarker Timer(TimerStack::TT_translateFunctions, this);
   while (std::unique_ptr<OptWorkItem> OptItem = optQueueBlockingPop()) {
     std::unique_ptr<EmitterWorkItem> Item;
     auto Func = OptItem->getParsedCfg();
     // Install Func in TLS for Cfg-specific container allocators.
     CfgLocalAllocatorScope _(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT match the
@@ skipping 62 matching lines @@
 
 // Ensure Pending is large enough that Pending[Index] is valid.
 void resizePending(std::vector<std::unique_ptr<EmitterWorkItem>> *Pending,
                    uint32_t Index) {
   if (Index >= Pending->size())
     Utils::reserveAndResize(*Pending, Index + 1);
 }
 
 } // end of anonymous namespace
 
+// static
+void GlobalContext::TlsInit() {
+  ICE_TLS_INIT_FIELD(TLS);
+}
+
 void GlobalContext::emitFileHeader() {
   TimerMarker T1(Ice::TimerStack::TT_emitAsm, this);
   if (getFlags().getOutFileType() == FT_Elf) {
     getObjectWriter()->writeInitialELFHeader();
   } else {
     if (!BuildDefs::dump()) {
       getStrError() << "emitFileHeader for non-ELF";
       getErrorStatus()->assign(EC_Translation);
     }
     TargetHeaderLowering::createLowering(this)->lower();
@@ skipping 82 matching lines @@
   // architectures this will waste 4 bytes.
   const SizeT Sizeof64BitNullPtr = typeWidthInBytes(IceType_i64);
   ProfileBlockInfoVarDecl->addInitializer(
       VariableDeclaration::ZeroInitializer::create(GlobalVariablePool.get(),
                                                    Sizeof64BitNullPtr));
   Globals.push_back(ProfileBlockInfoVarDecl);
   constexpr char ProfileDataSection[] = "$sz_profiler$";
   lowerGlobals(ProfileDataSection);
 }
 
+void GlobalContext::emitterWrapper(ThreadContext *MyTLS) {
+  ICE_TLS_SET_FIELD(TLS, MyTLS);
+  emitItems();
+}
+
 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::vector<std::unique_ptr<EmitterWorkItem>> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
@@ skipping 411 matching lines @@
   }
   if (getFlags().isSequential())
     emitItems();
 }
 
 std::unique_ptr<EmitterWorkItem> GlobalContext::emitQueueBlockingPop() {
   TimerMarker _(TimerStack::TT_qEmitPop, this);
   return EmitQ.blockingPop();
 }
 
+void GlobalContext::initParserThread() {
+  ThreadContext *Tls = new ThreadContext();
+  auto Timers = getTimers();
+  Timers->initInto(Tls->Timers);
+  AllThreadContexts.push_back(Tls);
+  ICE_TLS_SET_FIELD(TLS, Tls);
+}
+
+void GlobalContext::startWorkerThreads() {
+  size_t NumWorkers = getFlags().getNumTranslationThreads();
+  auto Timers = getTimers();
+  for (size_t i = 0; i < NumWorkers; ++i) {
+    ThreadContext *WorkerTLS = new ThreadContext();
+    Timers->initInto(WorkerTLS->Timers);
+    AllThreadContexts.push_back(WorkerTLS);
+    TranslationThreads.push_back(std::thread(
+        &GlobalContext::translateFunctionsWrapper, this, WorkerTLS));
+  }
+  if (NumWorkers) {
+    ThreadContext *WorkerTLS = new ThreadContext();
+    Timers->initInto(WorkerTLS->Timers);
+    AllThreadContexts.push_back(WorkerTLS);
+    EmitterThreads.push_back(
+        std::thread(&GlobalContext::emitterWrapper, this, WorkerTLS));
+  }
+}
+
+void GlobalContext::resetStats() {
+  if (BuildDefs::dump())
+    ICE_TLS_GET_FIELD(TLS)->StatsFunction.reset();
+}
+
 void GlobalContext::dumpStats(const Cfg *Func) {
   if (!getFlags().getDumpStats())
     return;
   if (Func == nullptr) {
     getStatsCumulative()->dump(Func, this);
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Func, this);
   }
 }
 
+void GlobalContext::statsUpdateEmitted(uint32_t InstCount) {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_InstCount, InstCount);
+  Tls->StatsCumulative.update(CodeStats::CS_InstCount, InstCount);
+}
+
+void GlobalContext::statsUpdateRegistersSaved(uint32_t Num) {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_RegsSaved, Num);
+  Tls->StatsCumulative.update(CodeStats::CS_RegsSaved, Num);
+}
+
+void GlobalContext::statsUpdateFrameBytes(uint32_t Bytes) {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_FrameByte, Bytes);
+  Tls->StatsCumulative.update(CodeStats::CS_FrameByte, Bytes);
+}
+
+void GlobalContext::statsUpdateSpills() {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_NumSpills);
+  Tls->StatsCumulative.update(CodeStats::CS_NumSpills);
+}
+
+void GlobalContext::statsUpdateFills() {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_NumFills);
+  Tls->StatsCumulative.update(CodeStats::CS_NumFills);
+}
+
+void GlobalContext::statsUpdateRPImms() {
+  if (!getFlags().getDumpStats())
+    return;
+  ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+  Tls->StatsFunction.update(CodeStats::CS_NumRPImms);
+  Tls->StatsCumulative.update(CodeStats::CS_NumRPImms);
+}
+
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::timers())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 void GlobalContext::dumpLocalTimers(const std::string &TimerNameOverride,
@@ skipping 48 matching lines @@
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active = Func->getFocusedTiming() || getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice