Remove an expensive lock from Timer

[scott.smith]

Summary

The Timer destructor would grab a global mutex in order to update execution time. Add a class to define a category once, statically; the class adds itself to an atomic singly linked list, and thus subsequent updates only need to use an atomic rather than grab a lock and perform a hashtable lookup.

[labath]

Don't forget to update the usages in unit tests (and make sure the check-lldb-unit target passes).

Seems reasonable, however: I am not sure who actually uses these timers. I'd be tempted to just remove the timers that are causing the contention.

include/lldb/Core/Timer.h

26 ↗

(On Diff #97708)

I would put this inside the Timer class, so that we can refer to it as Timer::Category. I guess tastes might differ.

source/Core/Timer.cpp

147 ↗

(On Diff #97708)

This could be a range-based loop.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

5421 ↗

(On Diff #97708)

I am not sure how you format your changes, but you should make sure you format only the lines you've touched, and not the whole files. git-clang-format https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/git-clang-format will do that for you -- when you set it up, you just run git clang-format HEAD^ and it will format your last patch).

[scott.smith]

In D32823#745799, @labath wrote:

Seems reasonable, however: I am not sure who actually uses these timers. I'd be tempted to just remove the timers that are causing the contention.

IMO we should either keep the timers and make them fast, or get rid of all timers. I don't like the idea of training developers to know that timers are slow, and should be used sparingly. Especially since the fix is relatively simple.

Though an atomic skip list would be another way to improve performance without requiring changing each callsite; the downside is the lg-n lookup when tallying the time.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

5421 ↗

(On Diff #97708)

Yeah that'll be helpful. I have default .emacs settings for work that don't necessarily apply well to the llvm codebase, this tool will make it easier to fix up.

[scott.smith]

updated per review comments.
added a test to fix the Jurassic Park problem.

[labath]

Ok, then let's keep them. I don't mind changing all call sites -- having a separate category object is the cleanest solution with least magic. However see my comments about category naming and merging.

unittests/Core/TimerTest.cpp

39 ↗

(On Diff #97880)

Do we actually need to support that? Since we already have a nice Category object then I think we should use that as a unique key for everything (including printing). There no reason why the category needs to have local scope. If it really needs to be used from multiple places, we can expose the object at a higher scope. For the tests, this could be done by having a fixture which creates the categories in the SetUpTestCase static function. Alternatively, we could have Category object be based on llvm::ManagedStatic, so it would go away when you call llvm_shutdown, which would enable us to have truly isolated and leak-free tests. (Right now we don't call llvm_shutdown in the main app as we cannot shutdown cleanly, but it would be great if one day we could.)

48 ↗

(On Diff #97880)

ss.GetStringRef().count("CAT1") == 1

[scott.smith]

remove same-name-different-site support from Timer::Category

unittests/Core/TimerTest.cpp

39 ↗

(On Diff #97880)

I don't think so.

git grep Timer::Category | grep -v LLVM_PRETTY_FUNCTION
shows one place (other than the unit test) where the name is explicitly set, and that's because that function already has its own scoped timer. All the other places are unique (one per function).

The test might be testing for recursion-safe timers, in which case I can just change the declaration of t2:
Timer t2(tcat1a, "")

so it uses the same category object.

[labath]

lgtm, thank you.

unittests/Core/TimerTest.cpp

39 ↗

(On Diff #97880)

Yes, the test was testing recursive timers (I wrote it).

[scott.smith]

Can someone please commit this? Thank you!

lldb/trunk/include/lldb/Core/Timer.h

 /// object is created, and unlocked when it goes out of scope or
 /// when the Timer::Locker::Reset(pthread_mutex_t *)
 /// is called. This provides an exception safe way to lock a mutex
 /// in a scope.
 //----------------------------------------------------------------------
 
 class Timer {
 public:
+  class Category {
+  public:
+    explicit Category(const char *category_name);
+
+  private:
+    friend class Timer;
+    const char *m_name;
+    std::atomic<uint64_t> m_nanos;
+    std::atomic<Category *> m_next;
+
+    DISALLOW_COPY_AND_ASSIGN(Category);
+  };
+
   //--------------------------------------------------------------
   /// Default constructor.
   //--------------------------------------------------------------
-  Timer(const char *category, const char *format, ...)
+  Timer(Category &category, const char *format, ...)
       __attribute__((format(printf, 3, 4)));
 
   //--------------------------------------------------------------
   /// Destructor
   //--------------------------------------------------------------
   ~Timer();
 
   void Dump();
 
   static void SetDisplayDepth(uint32_t depth);
 
   static void SetQuiet(bool value);
 
   static void DumpCategoryTimes(Stream *s);
 
   static void ResetCategoryTimes();
 
 protected:
   using TimePoint = std::chrono::steady_clock::time_point;
   void ChildDuration(TimePoint::duration dur) { m_child_duration += dur; }
 
-  const char *m_category;
+  Category &m_category;
   TimePoint m_total_start;
   TimePoint::duration m_child_duration{0};
 
   static std::atomic<bool> g_quiet;
   static std::atomic<unsigned> g_display_depth;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(Timer);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Timer_h_

lldb/trunk/source/API/SystemInitializerFull.cpp

ScriptInterpreterPython::InitializeInterpreter(
       LLDBSWIGPythonRunScriptKeywordThread,
       LLDBSWIGPythonRunScriptKeywordTarget, LLDBSWIGPythonRunScriptKeywordFrame,
       LLDBSWIGPythonRunScriptKeywordValue, LLDBSWIGPython_GetDynamicSetting,
       LLDBSwigPythonCreateScriptedThreadPlan, LLDBSWIGPythonCallThreadPlan);
 #endif
 }
 
 void SystemInitializerFull::Terminate() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger::SettingsTerminate();
 
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
   ClangASTContext::Terminate();
   GoASTContext::Terminate();

lldb/trunk/source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
           result.AppendErrorWithFormat("invalid symbol file path '%s'",
                                        symfile_path);
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
       }
 
       const char *file_path = command.GetArgumentAtIndex(0);
-      Timer scoped_timer(LLVM_PRETTY_FUNCTION, "(lldb) target create '%s'",
-                         file_path);
+      static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+      Timer scoped_timer(func_cat, "(lldb) target create '%s'", file_path);
       FileSpec file_spec;
 
       if (file_path)
         file_spec.SetFile(file_path, true);
 
       bool must_set_platform_path = false;
 
       Debugger &debugger = m_interpreter.GetDebugger();

lldb/trunk/source/Core/Disassembler.cpp

 #define DEFAULT_DISASM_BYTE_SIZE 32
 
 using namespace lldb;
 using namespace lldb_private;
 
 DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch,
                                         const char *flavor,
                                         const char *plugin_name) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "Disassembler::FindPlugin (arch = %s, plugin_name = %s)",
                      arch.GetArchitectureName(), plugin_name);
 
   DisassemblerCreateInstance create_callback = nullptr;
 
   if (plugin_name) {
     ConstString const_plugin_name(plugin_name);
     create_callback = PluginManager::GetDisassemblerCreateCallbackForPluginName(
return [&imm](const Instruction::Operand &op) {
     return true;
   };
 }
 
 std::function<bool(const Instruction::Operand &)>
 lldb_private::OperandMatchers::MatchOpType(Instruction::Operand::Type type) {
   return [type](const Instruction::Operand &op) { return op.m_type == type; };
 }
-

lldb/trunk/source/Core/Mangled.cpp

 // object's lifetime.
 //----------------------------------------------------------------------
 const ConstString &
 Mangled::GetDemangledName(lldb::LanguageType language) const {
   // Check to make sure we have a valid mangled name and that we
   // haven't already decoded our mangled name.
   if (m_mangled && !m_demangled) {
     // We need to generate and cache the demangled name.
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                       "Mangled::GetDemangledName (m_mangled = %s)",
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat, "Mangled::GetDemangledName (m_mangled = %s)",
                        m_mangled.GetCString());
 
     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE);
 
     // Don't bother running anything that isn't mangled
     const char *mangled_name = m_mangled.GetCString();
     ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
     if (mangling_scheme != eManglingSchemeNone &&

lldb/trunk/source/Core/Module.cpp

 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }
 
 void Module::DumpSymbolContext(Stream *s) {
   s->Printf(", Module{%p}", static_cast<void *>(this));
 }
 
 size_t Module::GetNumCompileUnits() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "Module::GetNumCompileUnits (module = %p)",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "Module::GetNumCompileUnits (module = %p)",
                      static_cast<void *>(this));
   SymbolVendor *symbols = GetSymbolVendor();
   if (symbols)
     return symbols->GetNumCompileUnits();
   return 0;
 }
 
 CompUnitSP Module::GetCompileUnitAtIndex(size_t index) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   size_t num_comp_units = GetNumCompileUnits();
   CompUnitSP cu_sp;
 
   if (index < num_comp_units) {
     SymbolVendor *symbols = GetSymbolVendor();
     if (symbols)
       cu_sp = symbols->GetCompileUnitAtIndex(index);
   }
   return cu_sp;
 }
 
 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "Module::ResolveFileAddress (vm_addr = 0x%" PRIx64 ")",
                      vm_addr);
   SectionList *section_list = GetSectionList();
   if (section_list)
     return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list);
   return false;
 }
 

 }
 
 uint32_t Module::ResolveSymbolContextsForFileSpec(const FileSpec &file_spec,
                                                   uint32_t line,
                                                   bool check_inlines,
                                                   uint32_t resolve_scope,
                                                   SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "Module::ResolveSymbolContextForFilePath (%s:%u, "
                      "check_inlines = %s, resolve_scope = 0x%8.8x)",
                      file_spec.GetPath().c_str(), line,
                      check_inlines ? "yes" : "no", resolve_scope);
 
   const uint32_t initial_count = sc_list.GetSize();
 
   SymbolVendor *symbols = GetSymbolVendor();
void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
   }
 }
 
 size_t Module::FindTypes_Impl(
     const SymbolContext &sc, const ConstString &name,
     const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   if (!sc.module_sp || sc.module_sp.get() == this) {
     SymbolVendor *symbols = GetSymbolVendor();
     if (symbols)
       return symbols->FindTypes(sc, name, parent_decl_ctx, append, max_matches,
                                 searched_symbol_files, types);
   }
   return 0;
 }

 
 SymbolVendor *Module::GetSymbolVendor(bool can_create,
                                       lldb_private::Stream *feedback_strm) {
   if (!m_did_load_symbol_vendor.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_symbol_vendor.load() && can_create) {
       ObjectFile *obj_file = GetObjectFile();
       if (obj_file != nullptr) {
-        Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+        static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+        Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
         m_symfile_ap.reset(
             SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
         m_did_load_symbol_vendor = true;
       }
     }
   }
   return m_symfile_ap.get();
 }

 }
 
 const ConstString &Module::GetObjectName() const { return m_object_name; }
 
 ObjectFile *Module::GetObjectFile() {
   if (!m_did_load_objfile.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_objfile.load()) {
-      Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                         "Module::GetObjectFile () module = %s",
+      static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+      Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s",
                          GetFileSpec().GetFilename().AsCString(""));
       DataBufferSP data_sp;
       lldb::offset_t data_offset = 0;
       const lldb::offset_t file_size = m_file.GetByteSize();
       if (file_size > m_object_offset) {
         m_did_load_objfile = true;
         m_objfile_sp = ObjectFile::FindPlugin(
             shared_from_this(), &m_file, m_object_offset,
SectionList *Module::GetUnifiedSectionList() {
   // Populate m_unified_sections_ap with sections from objfile.
   if (!m_sections_ap)
     m_sections_ap = llvm::make_unique<SectionList>();
   return m_sections_ap.get();
 }
 
 const Symbol *Module::FindFirstSymbolWithNameAndType(const ConstString &name,
                                                      SymbolType symbol_type) {
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
-      "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
+      func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
       name.AsCString(), symbol_type);
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor) {
     Symtab *symtab = sym_vendor->GetSymtab();
     if (symtab)
       return symtab->FindFirstSymbolWithNameAndType(
           name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
   }
for (size_t i = 0; i < num_indices; i++) {
         sc_list.Append(sc);
     }
   }
 }
 
 size_t Module::FindFunctionSymbols(const ConstString &name,
                                    uint32_t name_type_mask,
                                    SymbolContextList &sc_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
                      name.AsCString(), name_type_mask);
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor) {
     Symtab *symtab = sym_vendor->GetSymtab();
     if (symtab)
       return symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
   }
   return 0;
 }
 
 size_t Module::FindSymbolsWithNameAndType(const ConstString &name,
                                           SymbolType symbol_type,
                                           SymbolContextList &sc_list) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
-      "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
+      func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
       name.AsCString(), symbol_type);
   const size_t initial_size = sc_list.GetSize();
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor) {
     Symtab *symtab = sym_vendor->GetSymtab();
     if (symtab) {
       std::vector<uint32_t> symbol_indexes;
       symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
       SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
     }
   }
   return sc_list.GetSize() - initial_size;
 }
 
 size_t Module::FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
                                                SymbolType symbol_type,
                                                SymbolContextList &sc_list) {
   // No need to protect this call using m_mutex all other method calls are
   // already thread safe.
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
+      func_cat,
       "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
       regex.GetText().str().c_str(), symbol_type);
   const size_t initial_size = sc_list.GetSize();
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor) {
     Symtab *symtab = sym_vendor->GetSymtab();
     if (symtab) {
       std::vector<uint32_t> symbol_indexes;

lldb/trunk/source/Core/Timer.cpp

 #include <stdarg.h> // for va_end, va_list, va_start
 #include <stdio.h>
 
 using namespace lldb_private;
 
 #define TIMER_INDENT_AMOUNT 2
 
 namespace {
-typedef std::map<const char *, std::chrono::nanoseconds> TimerCategoryMap;
 typedef std::vector<Timer *> TimerStack;
+static std::atomic<Timer::Category *> g_categories;
 } // end of anonymous namespace
 
 std::atomic<bool> Timer::g_quiet(true);
 std::atomic<unsigned> Timer::g_display_depth(0);
 static std::mutex &GetFileMutex() {
   static std::mutex *g_file_mutex_ptr = new std::mutex();
   return *g_file_mutex_ptr;
 }
 
-static std::mutex &GetCategoryMutex() {
-  static std::mutex g_category_mutex;
-  return g_category_mutex;
-}
-
-static TimerCategoryMap &GetCategoryMap() {
-  static TimerCategoryMap g_category_map;
-  return g_category_map;
-}
-
 static void ThreadSpecificCleanup(void *p) {
   delete static_cast<TimerStack *>(p);
 }
 
 static TimerStack *GetTimerStackForCurrentThread() {
   static lldb::thread_key_t g_key =
       Host::ThreadLocalStorageCreate(ThreadSpecificCleanup);
 
   void *timer_stack = Host::ThreadLocalStorageGet(g_key);
   if (timer_stack == NULL) {
     Host::ThreadLocalStorageSet(g_key, new TimerStack);
     timer_stack = Host::ThreadLocalStorageGet(g_key);
   }
   return (TimerStack *)timer_stack;
 }
 
+Timer::Category::Category(const char *cat) : m_name(cat) {
+  m_nanos.store(0, std::memory_order_release);
+  Category *expected = g_categories;
+  do {
+    m_next = expected;
+  } while (!g_categories.compare_exchange_weak(expected, this));
+}
+
 void Timer::SetQuiet(bool value) { g_quiet = value; }
 
-Timer::Timer(const char *category, const char *format, ...)
+Timer::Timer(Timer::Category &category, const char *format, ...)
     : m_category(category), m_total_start(std::chrono::steady_clock::now()) {
   TimerStack *stack = GetTimerStackForCurrentThread();
   if (!stack)
     return;
 
   stack->push_back(this);
   if (g_quiet && stack->size() <= g_display_depth) {
     std::lock_guard<std::mutex> lock(GetFileMutex());
Timer::~Timer() {
   }
 
   assert(stack->back() == this);
   stack->pop_back();
   if (!stack->empty())
     stack->back()->ChildDuration(total_dur);
 
   // Keep total results for each category so we can dump results.
-  {
-    std::lock_guard<std::mutex> guard(GetCategoryMutex());
-    TimerCategoryMap &category_map = GetCategoryMap();
-    category_map[m_category] += timer_dur;
-  }
+  m_category.m_nanos += std::chrono::nanoseconds(timer_dur).count();
 }
 
 void Timer::SetDisplayDepth(uint32_t depth) { g_display_depth = depth; }
 
 /* binary function predicate:
  * - returns whether a person is less than another person
  */
-static bool
-CategoryMapIteratorSortCriterion(const TimerCategoryMap::const_iterator &lhs,
-                                 const TimerCategoryMap::const_iterator &rhs) {
-  return lhs->second > rhs->second;
+
+typedef std::pair<const char *, uint64_t> TimerEntry;
+
+static bool CategoryMapIteratorSortCriterion(const TimerEntry &lhs,
+                                             const TimerEntry &rhs) {
+  return lhs.second > rhs.second;
 }
 
 void Timer::ResetCategoryTimes() {
-  std::lock_guard<std::mutex> guard(GetCategoryMutex());
-  TimerCategoryMap &category_map = GetCategoryMap();
-  category_map.clear();
+  for (Category *i = g_categories; i; i = i->m_next)
+    i->m_nanos.store(0, std::memory_order_release);
 }
 
 void Timer::DumpCategoryTimes(Stream *s) {
-  std::lock_guard<std::mutex> guard(GetCategoryMutex());
-  TimerCategoryMap &category_map = GetCategoryMap();
-  std::vector<TimerCategoryMap::const_iterator> sorted_iterators;
-  TimerCategoryMap::const_iterator pos, end = category_map.end();
-  for (pos = category_map.begin(); pos != end; ++pos) {
-    sorted_iterators.push_back(pos);
-  }
-  std::sort(sorted_iterators.begin(), sorted_iterators.end(),
-            CategoryMapIteratorSortCriterion);
-
-  const size_t count = sorted_iterators.size();
-  for (size_t i = 0; i < count; ++i) {
-    const auto timer = sorted_iterators[i]->second;
-    s->Printf("%.9f sec for %s\n", std::chrono::duration<double>(timer).count(),
-              sorted_iterators[i]->first);
+  std::vector<TimerEntry> sorted;
+  for (Category *i = g_categories; i; i = i->m_next) {
+    uint64_t nanos = i->m_nanos.load(std::memory_order_acquire);
+    if (nanos)
+      sorted.push_back(std::make_pair(i->m_name, nanos));
   }
+  if (sorted.empty())
+    return; // Later code will break without any elements.
+
+  // Sort by time
+  std::sort(sorted.begin(), sorted.end(), CategoryMapIteratorSortCriterion);
+
+  for (const auto &timer : sorted)
+    s->Printf("%.9f sec for %s\n", timer.second / 1000000000., timer.first);
 }

lldb/trunk/source/Host/common/Symbols.cpp

static bool LocateDSYMInVincinityOfExecutable(const ModuleSpec &module_spec,
   return false;
 }
 
 FileSpec LocateExecutableSymbolFileDsym(const ModuleSpec &module_spec) {
   const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
   const ArchSpec *arch = module_spec.GetArchitecturePtr();
   const UUID *uuid = module_spec.GetUUIDPtr();
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
+      func_cat,
       "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)",
       exec_fspec ? exec_fspec->GetFilename().AsCString("<NULL>") : "<NULL>",
       arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid);
 
   FileSpec symbol_fspec;
   ModuleSpec dsym_module_spec;
   // First try and find the dSYM in the same directory as the executable or in
   // an appropriate parent directory
   if (LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec) == false) {
     // We failed to easily find the dSYM above, so use DebugSymbols
     LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec);
   } else {
     dsym_module_spec.GetSymbolFileSpec() = symbol_fspec;
   }
   return dsym_module_spec.GetSymbolFileSpec();
 }
 
 ModuleSpec Symbols::LocateExecutableObjectFile(const ModuleSpec &module_spec) {
   ModuleSpec result;
   const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
   const ArchSpec *arch = module_spec.GetArchitecturePtr();
   const UUID *uuid = module_spec.GetUUIDPtr();
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
-      "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
+      func_cat, "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
       exec_fspec ? exec_fspec->GetFilename().AsCString("<NULL>") : "<NULL>",
       arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid);
 
   ModuleSpecList module_specs;
   ModuleSpec matched_module_spec;
   if (exec_fspec &&
       ObjectFile::GetModuleSpecifications(*exec_fspec, 0, 0, module_specs) &&
       module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec)) {

lldb/trunk/source/Initialization/SystemInitializerCommon.cpp

if (disable_crash_dialog_var &&
     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
   }
 #endif
 
   llvm::EnablePrettyStackTrace();
   InitializeLog();
   HostInfo::Initialize();
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
   // Initialize plug-ins
   ObjectContainerBSDArchive::Initialize();
   ObjectFileELF::Initialize();
   ObjectFilePECOFF::Initialize();
 
#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
   ProcessPOSIXLog::Initialize();
 #endif
 #if defined(_MSC_VER)
   ProcessWindowsLog::Initialize();
 #endif
 }
 
 void SystemInitializerCommon::Terminate() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   ObjectContainerBSDArchive::Terminate();
   ObjectFileELF::Terminate();
   ObjectFilePECOFF::Terminate();
 
   EmulateInstructionARM::Terminate();
   EmulateInstructionMIPS::Terminate();
   EmulateInstructionMIPS64::Terminate();
 

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

 
 bool CommandInterpreter::GetSpaceReplPrompts() const {
   const uint32_t idx = eSpaceReplPrompts;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 void CommandInterpreter::Initialize() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   CommandReturnObject result;
 
   LoadCommandDictionary();
 
   // An alias arguments vector to reuse - reset it before use...
   OptionArgVectorSP alias_arguments_vector_sp(new OptionArgVector);
 
const char *CommandInterpreter::ProcessEmbeddedScriptCommands(const char *arg) {
   //    call execute_one_command on it,
   //    get the results as a string,
   //    substitute that string for current stuff.
 
   return arg;
 }
 
 void CommandInterpreter::LoadCommandDictionary() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage();
 
   m_command_dict["apropos"] = CommandObjectSP(new CommandObjectApropos(*this));
   m_command_dict["breakpoint"] =
       CommandObjectSP(new CommandObjectMultiwordBreakpoint(*this));
   m_command_dict["bugreport"] =
       CommandObjectSP(new CommandObjectMultiwordBugreport(*this));
bool CommandInterpreter::HandleCommand(const char *command_line,
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS));
   llvm::PrettyStackTraceFormat stack_trace("HandleCommand(command = \"%s\")",
                                    command_line);
 
   if (log)
     log->Printf("Processing command: %s", command_line);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "Handling command: %s.",
-                     command_line);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "Handling command: %s.", command_line);
 
   if (!no_context_switching)
     UpdateExecutionContext(override_context);
 
   bool add_to_history;
   if (lazy_add_to_history == eLazyBoolCalculate)
     add_to_history = (m_command_source_depth == 0);
   else

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

if (process) {
     }
   }
   return LLDB_INVALID_ADDRESS;
 }
 
 void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   // Else we need to check with our process to see when the map was updated.
   Process *process = GetProcess();
 
   if (process) {
     RemoteNXMapTable hash_table;
 
     // Update the process stop ID that indicates the last time we updated the

lldb/trunk/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

ObjectContainer *ObjectContainerBSDArchive::CreateInstance(
 
   if (data_sp) {
     // We have data, which means this is the first 512 bytes of the file
     // Check to see if the magic bytes match and if they do, read the entire
     // table of contents for the archive and cache it
     DataExtractor data;
     data.SetData(data_sp, data_offset, length);
     if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data)) {
+      static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
       Timer scoped_timer(
-          LLVM_PRETTY_FUNCTION,
+          func_cat,
           "ObjectContainerBSDArchive::CreateInstance (module = %s, file = "
           "%p, file_offset = 0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
           module_sp->GetFileSpec().GetPath().c_str(),
           static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
           static_cast<uint64_t>(length));
 
       // Map the entire .a file to be sure that we don't lose any data if the
       // file gets updated by a new build while this .a file is being used for

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (header.Parse(data, &header_offset)) {
                         __FUNCTION__, file.GetPath().c_str(),
                         spec_triple.getTriple().c_str(),
                         spec.GetArchitecture().GetArchitectureName());
 
           if (!uuid.IsValid()) {
             uint32_t core_notes_crc = 0;
 
             if (!gnu_debuglink_crc) {
+              static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
               lldb_private::Timer scoped_timer(
-                  LLVM_PRETTY_FUNCTION,
+                  func_cat,
                   "Calculating module crc32 %s with size %" PRIu64 " KiB",
                   file.GetLastPathComponent().AsCString(),
                   (file.GetByteSize() - file_offset) / 1024);
 
               // For core files - which usually don't happen to have a
               // gnu_debuglink, and are pretty bulky - calculating whole
               // contents crc32 would be too much of luxury.  Thus we will need
               // to fallback to something simpler.

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (strcmp(version_str, "dyld_v") == 0) {
     memcpy(uuid_bytes, dsc_header_data.GetData(&offset, sizeof(uuid_t)),
            sizeof(uuid_t));
     dsc_uuid.SetBytes(uuid_bytes);
   }
   return dsc_uuid;
 }
 
 size_t ObjectFileMachO::ParseSymtab() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "ObjectFileMachO::ParseSymtab () module = %s",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "ObjectFileMachO::ParseSymtab () module = %s",
                      m_file.GetFilename().AsCString(""));
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return 0;
 
   struct symtab_command symtab_load_command = {0, 0, 0, 0, 0, 0};
   struct linkedit_data_command function_starts_load_command = {0, 0, 0, 0};
   struct dyld_info_command dyld_info = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

public:
 
   void GotEOF() override {}
 
 protected:
   ScriptInterpreterPython *m_python;
 };
 
 void ScriptInterpreterPython::ExecuteInterpreterLoop() {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger &debugger = GetCommandInterpreter().GetDebugger();
 
   // At the moment, the only time the debugger does not have an input file
   // handle is when this is called
   // directly from Python, in which case it is both dangerous and unnecessary
   // (not to mention confusing) to
   // try to embed a running interpreter loop inside the already running Python
bool ScriptInterpreterPython::GenerateWatchpointCommandCallbackData(
   return true;
 }
 
 bool ScriptInterpreterPython::GetScriptedSummary(
     const char *python_function_name, lldb::ValueObjectSP valobj,
     StructuredData::ObjectSP &callee_wrapper_sp,
     const TypeSummaryOptions &options, std::string &retval) {
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   if (!valobj.get()) {
     retval.assign("<no object>");
     return false;
   }
 
   void *old_callee = nullptr;
   StructuredData::Generic *generic = nullptr;
   if (callee_wrapper_sp) {
     generic = callee_wrapper_sp->GetAsGeneric();
     if (generic)
       old_callee = generic->GetValue();
   }
   void *new_callee = old_callee;
 
   bool ret_val;
   if (python_function_name && *python_function_name) {
     {
       Locker py_lock(this, Locker::AcquireLock | Locker::InitSession |
                                Locker::NoSTDIN);
       {
         TypeSummaryOptionsSP options_sp(new TypeSummaryOptions(options));
 
-        Timer scoped_timer("g_swig_typescript_callback",
-                           "g_swig_typescript_callback");
+        static Timer::Category func_cat("g_swig_typescript_callback");
+        Timer scoped_timer(func_cat, "g_swig_typescript_callback");
         ret_val = g_swig_typescript_callback(
             python_function_name, GetSessionDictionary().get(), valobj,
             &new_callee, options_sp, retval);
       }
     }
   } else {
     retval.assign("<no function name>");
     return false;

 }
 
 void ScriptInterpreterPython::InitializePrivate() {
   if (g_initialized)
     return;
 
   g_initialized = true;
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   // RAII-based initialization which correctly handles multiple-initialization,
   // version-
   // specific differences among Python 2 and Python 3, and saving and restoring
   // various
   // other pieces of state that can get mucked with during initialization.
   InitializePythonRAII initialize_guard;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 // Parses a compile unit and indexes its DIEs if it hasn't already been
 // done.
 //----------------------------------------------------------------------
 size_t DWARFCompileUnit::ExtractDIEsIfNeeded(bool cu_die_only) {
   const size_t initial_die_array_size = m_die_array.size();
   if ((cu_die_only && initial_die_array_size > 0) || initial_die_array_size > 1)
     return 0; // Already parsed
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
+      func_cat,
       "%8.8x: DWARFCompileUnit::ExtractDIEsIfNeeded( cu_die_only = %i )",
       m_offset, cu_die_only);
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
   lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp

 
 void DWARFDebugAranges::AppendRange(dw_offset_t offset, dw_addr_t low_pc,
                                     dw_addr_t high_pc) {
   if (high_pc > low_pc)
     m_aranges.Append(RangeToDIE::Entry(low_pc, high_pc - low_pc, offset));
 }
 
 void DWARFDebugAranges::Sort(bool minimize) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s this = %p", LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
                      static_cast<void *>(this));
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES));
   size_t orig_arange_size = 0;
   if (log) {
     orig_arange_size = m_aranges.GetSize();
     log->Printf("DWARFDebugAranges::Sort(minimize = %u) with %" PRIu64
                 " entries",

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

 bool DWARFDebugLine::ParseStatementTable(
     const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
     DWARFDebugLine::State::Callback callback, void *userData) {
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_LINE));
   Prologue::shared_ptr prologue(new Prologue());
 
   const dw_offset_t debug_line_offset = *offset_ptr;
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
-      "DWARFDebugLine::ParseStatementTable (.debug_line[0x%8.8x])",
+      func_cat, "DWARFDebugLine::ParseStatementTable (.debug_line[0x%8.8x])",
       debug_line_offset);
 
   if (!ParsePrologue(debug_line_data, offset_ptr, prologue.get())) {
     if (log)
       log->Error("failed to parse DWARF line table prologue");
     // Restore our offset and return false to indicate failure!
     *offset_ptr = debug_line_offset;
     return false;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp

 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DWARFDebugPubnames::DWARFDebugPubnames() : m_sets() {}
 
 bool DWARFDebugPubnames::Extract(const DWARFDataExtractor &data) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "DWARFDebugPubnames::Extract (byte_size = %" PRIu64 ")",
                      (uint64_t)data.GetByteSize());
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_PUBNAMES));
   if (log)
     log->Printf("DWARFDebugPubnames::Extract (byte_size = %" PRIu64 ")",
                 (uint64_t)data.GetByteSize());
 
   if (data.ValidOffset(0)) {
if (data.ValidOffset(0)) {
     if (log)
       Dump(log);
     return true;
   }
   return false;
 }
 
 bool DWARFDebugPubnames::GeneratePubnames(SymbolFileDWARF *dwarf2Data) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "DWARFDebugPubnames::GeneratePubnames (data = %p)",
                      static_cast<void *>(dwarf2Data));
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_PUBNAMES));
   if (log)
     log->Printf("DWARFDebugPubnames::GeneratePubnames (data = %p)",
                 static_cast<void *>(dwarf2Data));
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 }
 
 const DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() const {
   return m_abbr.get();
 }
 
 DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
   if (m_info.get() == NULL) {
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s this = %p",
-                       LLVM_PRETTY_FUNCTION, static_cast<void *>(this));
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
+                       static_cast<void *>(this));
     if (get_debug_info_data().GetByteSize() > 0) {
       m_info.reset(new DWARFDebugInfo());
       if (m_info.get()) {
         m_info->SetDwarfData(this);
       }
     }
   }
   return m_info.get();
if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
 DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {
   if (m_ranges.get() == NULL) {
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s this = %p",
-                       LLVM_PRETTY_FUNCTION, static_cast<void *>(this));
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
+                       static_cast<void *>(this));
     if (get_debug_ranges_data().GetByteSize() > 0) {
       m_ranges.reset(new DWARFDebugRanges());
       if (m_ranges.get())
         m_ranges->Extract(this);
     }
   }
   return m_ranges.get();
 }
if (!m_global_aranges_ap) {
     m_global_aranges_ap->Sort();
   }
   return *m_global_aranges_ap;
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
                                                uint32_t resolve_scope,
                                                SymbolContext &sc) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "SymbolFileDWARF::"
-                                           "ResolveSymbolContext (so_addr = { "
-                                           "section = %p, offset = 0x%" PRIx64
-                                           " }, resolve_scope = 0x%8.8x)",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
+                     "SymbolFileDWARF::"
                      static_cast<void *>(so_addr.GetSection().get()),
                      so_addr.GetOffset(), resolve_scope);
   uint32_t resolved = 0;
   if (resolve_scope &
       (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
        eSymbolContextLineEntry | eSymbolContextVariable)) {
     lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
 
std::lock_guard<std::recursive_mutex> guard(
       GetObjectFile()->GetModule()->GetMutex());
   Index();
 }
 
 void SymbolFileDWARF::Index() {
   if (m_indexed)
     return;
   m_indexed = true;
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION, "SymbolFileDWARF::Index (%s)",
+      func_cat, "SymbolFileDWARF::Index (%s)",
       GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>"));
 
   DWARFDebugInfo *debug_info = DebugInfo();
   if (debug_info) {
     const uint32_t num_compile_units = GetNumCompileUnits();
     if (num_compile_units == 0)
       return;
 
bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
   return false;
 }
 
 uint32_t
 SymbolFileDWARF::FindFunctions(const ConstString &name,
                                const CompilerDeclContext *parent_decl_ctx,
                                uint32_t name_type_mask, bool include_inlines,
                                bool append, SymbolContextList &sc_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "SymbolFileDWARF::FindFunctions (name = '%s')",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
                      name.AsCString());
 
   // eFunctionNameTypeAuto should be pre-resolved by a call to
   // Module::LookupInfo::LookupInfo()
   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
GetObjectFile()->GetModule()->LogMessage(
         num_matches);
   }
   return num_matches;
 }
 
 uint32_t SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
                                         bool include_inlines, bool append,
                                         SymbolContextList &sc_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "SymbolFileDWARF::FindFunctions (regex = '%s')",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (regex = '%s')",
                      regex.GetText().str().c_str());
 
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

while (i < sc_list.GetSize()) {
     ++i;
   }
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindFunctions(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
     uint32_t name_type_mask, bool include_inlines, bool append,
     SymbolContextList &sc_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
                      name.GetCString());
 
   uint32_t initial_size = 0;
   if (append)
     initial_size = sc_list.GetSize();
   else
     sc_list.Clear();
uint32_t SymbolFileDWARFDebugMap::FindFunctions(
 
   return sc_list.GetSize() - initial_size;
 }
 
 uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
                                                 bool include_inlines,
                                                 bool append,
                                                 SymbolContextList &sc_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
                      regex.GetText().str().c_str());
 
   uint32_t initial_size = 0;
   if (append)
     initial_size = sc_list.GetSize();
   else
     sc_list.Clear();
uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
   });
 
   return sc_list.GetSize() - initial_size;
 }
 
 size_t SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope,
                                          uint32_t type_mask,
                                          TypeList &type_list) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat,
                      "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
                      type_mask);
 
   uint32_t initial_size = type_list.GetSize();
   SymbolFileDWARF *oso_dwarf = NULL;
   if (sc_scope) {
     SymbolContext sc;
     sc_scope->CalculateSymbolContext(&sc);

lldb/trunk/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
   FileSpec debug_symbol_fspec(module_sp->GetSymbolFileFileSpec());
   if (debug_symbol_fspec)
     file_spec_list.Insert(0, debug_symbol_fspec);
 
   // If we have no debug symbol files, then nothing to do.
   if (file_spec_list.IsEmpty())
     return NULL;
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "SymbolVendorELF::CreateInstance (module = %s)",
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "SymbolVendorELF::CreateInstance (module = %s)",
                      module_sp->GetFileSpec().GetPath().c_str());
 
   for (size_t idx = 0; idx < file_spec_list.GetSize(); ++idx) {
     ModuleSpec module_spec;
     const FileSpec fspec = file_spec_list.GetFileSpecAtIndex(idx);
 
     module_spec.GetFileSpec() = obj_file->GetFileSpec();
     module_spec.GetFileSpec().ResolvePath();

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

void DWARFCallFrameInfo::GetFDEIndex() {
   if (m_fde_index_initialized)
     return;
 
   std::lock_guard<std::mutex> guard(m_fde_index_mutex);
 
   if (m_fde_index_initialized) // if two threads hit the locker
     return;
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s - %s", LLVM_PRETTY_FUNCTION,
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s - %s", LLVM_PRETTY_FUNCTION,
                      m_objfile.GetFileSpec().GetFilename().AsCString(""));
 
   bool clear_address_zeroth_bit = false;
   ArchSpec arch;
   if (m_objfile.GetArchitecture(arch)) {
     if (arch.GetTriple().getArch() == llvm::Triple::arm ||
         arch.GetTriple().getArch() == llvm::Triple::thumb)
       clear_address_zeroth_bit = true;

lldb/trunk/source/Symbol/ObjectFile.cpp

 
 ObjectFileSP
 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
                        lldb::offset_t file_offset, lldb::offset_t file_size,
                        DataBufferSP &data_sp, lldb::offset_t &data_offset) {
   ObjectFileSP object_file_sp;
 
   if (module_sp) {
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(
-        LLVM_PRETTY_FUNCTION,
+        func_cat,
         "ObjectFile::FindPlugin (module = %s, file = %p, file_offset = "
         "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
         module_sp->GetFileSpec().GetPath().c_str(),
         static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
         static_cast<uint64_t>(file_size));
     if (file) {
       FileSpec archive_file;
       ObjectContainerCreateInstance create_object_container_callback;

 
 ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
                                     const ProcessSP &process_sp,
                                     lldb::addr_t header_addr,
                                     DataBufferSP &data_sp) {
   ObjectFileSP object_file_sp;
 
   if (module_sp) {
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION, "ObjectFile::FindPlugin (module = "
-                                             "%s, process = %p, header_addr = "
-                                             "0x%" PRIx64 ")",
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat,
+                       "ObjectFile::FindPlugin (module = "
                        module_sp->GetFileSpec().GetPath().c_str(),
                        static_cast<void *>(process_sp.get()), header_addr);
     uint32_t idx;
 
     // Check if this is a normal object file by iterating through
     // all object file plugin instances.
     ObjectFileCreateMemoryInstance create_callback;
     for (idx = 0;

lldb/trunk/source/Symbol/Symtab.cpp

 
 //----------------------------------------------------------------------
 // InitNameIndexes
 //----------------------------------------------------------------------
 void Symtab::InitNameIndexes() {
   // Protected function, no need to lock mutex...
   if (!m_name_indexes_computed) {
     m_name_indexes_computed = true;
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
     // Create the name index vector to be able to quickly search by name
     const size_t num_symbols = m_symbols.size();
 #if 1
     m_name_to_index.Reserve(num_symbols);
 #else
     // TODO: benchmark this to see if we save any memory. Otherwise we
     // will always keep the memory reserved in the vector unless we pull
     // some STL swap magic and then recopy...
void Symtab::PreloadSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   InitNameIndexes();
 }
 
 void Symtab::AppendSymbolNamesToMap(const IndexCollection &indexes,
                                     bool add_demangled, bool add_mangled,
                                     NameToIndexMap &name_to_index_map) const {
   if (add_demangled || add_mangled) {
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Create the name index vector to be able to quickly search by name
     NameToIndexMap::Entry entry;
     const size_t num_indexes = indexes.size();
     for (size_t i = 0; i < num_indexes; ++i) {
       entry.value = indexes[i];
       assert(i < m_symbols.size());
struct SymbolIndexComparator {
   }
 };
 }
 
 void Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
                                       bool remove_duplicates) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
   // No need to sort if we have zero or one items...
   if (indexes.size() <= 1)
     return;
 
   // Sort the indexes in place using std::stable_sort.
   // NOTE: The use of std::stable_sort instead of std::sort here is strictly for
   // performance,
   // not correctness.  The indexes vector tends to be "close" to sorted, which
void Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
   if (remove_duplicates)
     std::unique(indexes.begin(), indexes.end());
 }
 
 uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name,
                                              std::vector<uint32_t> &indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
   if (symbol_name) {
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
     return m_name_to_index.GetValues(symbol_name, indexes);
   }
   return 0;
 }
 
 uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name,
                                              Debug symbol_debug_type,
                                              Visibility symbol_visibility,
                                              std::vector<uint32_t> &indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
   if (symbol_name) {
     const size_t old_size = indexes.size();
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
     std::vector<uint32_t> all_name_indexes;
     const size_t name_match_count =
         m_name_to_index.GetValues(symbol_name, all_name_indexes);

 }
 
 size_t
 Symtab::FindAllSymbolsWithNameAndType(const ConstString &name,
                                       SymbolType symbol_type,
                                       std::vector<uint32_t> &symbol_indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
   // Initialize all of the lookup by name indexes before converting NAME
   // to a uniqued string NAME_STR below.
   if (!m_name_indexes_computed)
     InitNameIndexes();
 
   if (name) {
     // The string table did have a string that matched, but we need
     // to check the symbols and match the symbol_type if any was given.
     AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes);
   }
   return symbol_indexes.size();
 }
 
 size_t Symtab::FindAllSymbolsWithNameAndType(
     const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type,
     Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
   // Initialize all of the lookup by name indexes before converting NAME
   // to a uniqued string NAME_STR below.
   if (!m_name_indexes_computed)
     InitNameIndexes();
 
   if (name) {
     // The string table did have a string that matched, but we need
     // to check the symbols and match the symbol_type if any was given.

 }
 
 Symbol *Symtab::FindFirstSymbolWithNameAndType(const ConstString &name,
                                                SymbolType symbol_type,
                                                Debug symbol_debug_type,
                                                Visibility symbol_visibility) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION, "%s", LLVM_PRETTY_FUNCTION);
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
   if (!m_name_indexes_computed)
     InitNameIndexes();
 
   if (name) {
     std::vector<uint32_t> matching_indexes;
     // The string table did have a string that matched, but we need
     // to check the symbols and match the symbol_type if any was given.
     if (AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,

lldb/trunk/source/Target/Target.cpp

 }
 
 void Target::SetExecutableModule(ModuleSP &executable_sp,
                                  bool get_dependent_files) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
   ClearModules(false);
 
   if (executable_sp) {
-    Timer scoped_timer(LLVM_PRETTY_FUNCTION,
+    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+    Timer scoped_timer(func_cat,
                        "Target::SetExecutableModule (executable = '%s')",
                        executable_sp->GetFileSpec().GetPath().c_str());
 
     m_images.Append(executable_sp); // The first image is our executable file
 
     // If we haven't set an architecture yet, reset our architecture based on
     // what we found in the executable module.
     if (!m_arch.IsValid()) {

lldb/trunk/source/Target/TargetList.cpp

 
 Status TargetList::CreateTargetInternal(Debugger &debugger,
                                         llvm::StringRef user_exe_path,
                                         const ArchSpec &specified_arch,
                                         bool get_dependent_files,
                                         lldb::PlatformSP &platform_sp,
                                         lldb::TargetSP &target_sp,
                                         bool is_dummy_target) {
-  Timer scoped_timer(LLVM_PRETTY_FUNCTION,
-                     "TargetList::CreateTarget (file = '%s', arch = '%s')",
-                     user_exe_path.str().c_str(),
-                     specified_arch.GetArchitectureName());
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
+  Timer scoped_timer(
+      func_cat, "TargetList::CreateTarget (file = '%s', arch = '%s')",
+      user_exe_path.str().c_str(), specified_arch.GetArchitectureName());
   Status error;
 
   ArchSpec arch(specified_arch);
 
   if (arch.IsValid()) {
     if (!platform_sp ||
         !platform_sp->IsCompatibleArchitecture(arch, false, nullptr))
       platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);

lldb/trunk/unittests/Core/TimerTest.cpp

 #include "lldb/Utility/StreamString.h"
 #include <thread>
 
 using namespace lldb_private;
 
 TEST(TimerTest, CategoryTimes) {
   Timer::ResetCategoryTimes();
   {
-    Timer t("CAT1", "");
+    static Timer::Category tcat("CAT1");
+    Timer t(tcat, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
   Timer::DumpCategoryTimes(&ss);
   double seconds;
   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   EXPECT_LT(0.001, seconds);
   EXPECT_GT(0.1, seconds);
 }
 
 TEST(TimerTest, CategoryTimesNested) {
   Timer::ResetCategoryTimes();
   {
-    Timer t1("CAT1", "");
+    static Timer::Category tcat1("CAT1");
+    Timer t1(tcat1, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    Timer t2("CAT1", "");
+    // Explicitly testing the same category as above.
+    Timer t2(tcat1, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
   Timer::DumpCategoryTimes(&ss);
   double seconds;
+  // It should only appear once.
+  ASSERT_EQ(ss.GetString().count("CAT1"), 1U);
   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   EXPECT_LT(0.002, seconds);
   EXPECT_GT(0.2, seconds);
 }
 
 TEST(TimerTest, CategoryTimes2) {
   Timer::ResetCategoryTimes();
   {
-    Timer t1("CAT1", "");
+    static Timer::Category tcat1("CAT1");
+    Timer t1(tcat1, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    Timer t2("CAT2", "");
+    static Timer::Category tcat2("CAT2");
+    Timer t2(tcat2, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
   Timer::DumpCategoryTimes(&ss);
   double seconds1, seconds2;
   ASSERT_EQ(2, sscanf(ss.GetData(), "%lf sec for CAT1%*[\n ]%lf sec for CAT2",
                       &seconds1, &seconds2))
       << "String: " << ss.GetData();
   EXPECT_LT(0.01, seconds1);
   EXPECT_GT(1, seconds1);
   EXPECT_LT(0.001, seconds2);
   EXPECT_GT(0.1, seconds2);
 }