Subzero: Fix -timing-focus .

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 869 matching lines @@
   if (!BuildDefs::timers())
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const std::string &Name) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   return Timers->at(StackID).getTimerID(Name);
 }
 
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).reset();
 }
 
+std::string GlobalContext::getTimerName(TimerStackIdT StackID) {
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < Timers->size());
+  return Timers->at(StackID).getName();
+}
+
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const std::string &NewName) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
 // Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr at the
 // interface to take and transfer ownership, but they internally store the raw
 // Cfg pointer in the work queue. This allows e.g. future queue optimizations
 // such as the use of atomics to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<OptWorkItem> Item) {
   assert(Item);
@@ skipping 29 matching lines @@
 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::mergeTimersFromTLS() {
-  getTimers()->mergeFrom(ICE_TLS_GET_FIELD(TLS)->Timers);
-}
-
 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,
+                                    TimerStackIdT StackID,
+                                    bool DumpCumulative) {
+  if (!BuildDefs::timers())
+    return;
+  auto *Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(Timers->size() > StackID);
+  // Temporarily override the thread-local timer name with the given name.
+  // Don't do it permanently because the final timer merge at the end expects
+  // the thread-local timer names to be the same as the global timer name.
+  auto OrigName = getTimerName(StackID);
+  setTimerName(StackID, TimerNameOverride);
+  {
+    OstreamLocker _(this);
+    Timers->at(StackID).dump(getStrDump(), DumpCumulative);
+  }
+  setTimerName(StackID, OrigName);
+}
+
 LockedPtr<StringPool>
 GlobalStringPoolTraits::getStrings(const GlobalContext *PoolOwner) {
   return PoolOwner->getStrings();
 }
 
 TimerIdT TimerMarker::getTimerIdFromFuncName(GlobalContext *Ctx,
                                              const std::string &FuncName) {
   if (!BuildDefs::timers())
     return 0;
   if (!getFlags().getTimeEachFunction())
@@ skipping 20 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