[lldb] Remove some trivial scoped timers

[kastiglione]

Summary

While profiling lldb (from swift/llvm-project), these timers were noticed to be short lived and high firing, and so they add noise more than value.

The data points I recorded are:

FindTypes_Impl: 49,646 calls, 812ns avg, 40.33ms total
AppendSymbolIndexesWithName: 36,229 calls, 913ns avg, 33.09ms total
FindAllSymbolsWithNameAndType: 36,229 calls, 1.93µs avg, 70.05ms total
FindSymbolsWithNameAndType: 23,263 calls, 3.09µs avg, 71.88ms total

[JDevlieghere]

These functions seem hot enough that the overhead of the timer outweighs the value it brings. LGTM.

lldb/source/Core/Module.cpp

void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
   }
 }
 
 void Module::FindTypes_Impl(
     ConstString name, const CompilerDeclContext &parent_decl_ctx,
     size_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
     TypeMap &types) {
-  LLDB_SCOPED_TIMER();
   if (SymbolFile *symbols = GetSymbolFile())
     symbols->FindTypes(name, parent_decl_ctx, max_matches,
                        searched_symbol_files, types);
 }
 
 void Module::FindTypesInNamespace(ConstString type_name,
                                   const CompilerDeclContext &parent_decl_ctx,
                                   size_t max_matches, TypeList &type_list) {
if (Symtab *symtab = GetSymtab())
     symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
 }
 
 void Module::FindSymbolsWithNameAndType(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.
-  LLDB_SCOPED_TIMERF(
-      "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
-      name.AsCString(), symbol_type);
   if (Symtab *symtab = GetSymtab()) {
     std::vector<uint32_t> symbol_indexes;
     symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
     SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
   }
 }
 
 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression &regex,

lldb/source/Symbol/Symtab.cpp

uint32_t Symtab::GetNameIndexes(ConstString symbol_name,
   indexes.push_back(symbol_idx);
   return 1;
 }
 
 uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
                                              std::vector<uint32_t> &indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  LLDB_SCOPED_TIMER();
   if (symbol_name) {
     if (!m_name_indexes_computed)
       InitNameIndexes();
 
     return GetNameIndexes(symbol_name, indexes);
   }
   return 0;
 }

 }
 
 void
 Symtab::FindAllSymbolsWithNameAndType(ConstString name,
                                       SymbolType symbol_type,
                                       std::vector<uint32_t> &symbol_indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  LLDB_SCOPED_TIMER();
   // 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.