[lldb] Remove ClangASTMetrics

[teemperor]

Summary

Not once have I looked at these numbers in a log and considered them useful for anything. Also we should not implement this (or anything) via unguarded list of globals.

[shafik]

It is not clear to me we could use these in a test because I don't see a reason for the numbers to stay stable and therefore a useful measure.

lldb/include/lldb/Symbol/ClangASTImporter.h

 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CxxModuleHandler.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 
-class ClangASTMetrics {
-public:
-  static void DumpCounters(Log *log);
-  static void ClearLocalCounters() { local_counters = {0, 0, 0, 0, 0, 0}; }
-
-  static void RegisterVisibleQuery() {
-    ++global_counters.m_visible_query_count;
-    ++local_counters.m_visible_query_count;
-  }
-
-  static void RegisterLexicalQuery() {
-    ++global_counters.m_lexical_query_count;
-    ++local_counters.m_lexical_query_count;
-  }
-
-  static void RegisterLLDBImport() {
-    ++global_counters.m_lldb_import_count;
-    ++local_counters.m_lldb_import_count;
-  }
-
-  static void RegisterClangImport() {
-    ++global_counters.m_clang_import_count;
-    ++local_counters.m_clang_import_count;
-  }
-
-  static void RegisterDeclCompletion() {
-    ++global_counters.m_decls_completed_count;
-    ++local_counters.m_decls_completed_count;
-  }
-
-  static void RegisterRecordLayout() {
-    ++global_counters.m_record_layout_count;
-    ++local_counters.m_record_layout_count;
-  }
-
-private:
-  struct Counters {
-    uint64_t m_visible_query_count;
-    uint64_t m_lexical_query_count;
-    uint64_t m_lldb_import_count;
-    uint64_t m_clang_import_count;
-    uint64_t m_decls_completed_count;
-    uint64_t m_record_layout_count;
-  };
-
-  static Counters global_counters;
-  static Counters local_counters;
-
-  static void DumpCounters(Log *log, Counters &counters);
-};
-
 class ClangASTImporter {
 public:
   struct LayoutInfo {
     LayoutInfo()
         : bit_size(0), alignment(0), field_offsets(), base_offsets(),
           vbase_offsets() {}
     uint64_t bit_size;
     uint64_t alignment;

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl_context)) {
       }
     }
     return GetMergerUnchecked().FindExternalLexicalDecls(decl_context,
                                                          predicate,
                                                          decls);
   } else if (!m_ast_importer_sp)
     return;
 
-  ClangASTMetrics::RegisterLexicalQuery();
-
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   const Decl *context_decl = dyn_cast<Decl>(decl_context);
 
   if (!context_decl)
     return;
 
   auto iter = m_active_lexical_decls.find(context_decl);
void ClangASTSource::FindExternalLexicalDecls(
   }
 
   return;
 }
 
 void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) {
   assert(m_ast_context);
 
-  ClangASTMetrics::RegisterVisibleQuery();
-
   const ConstString name(context.m_decl_name.getAsString().c_str());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   if (log) {
bool ExtractBaseOffsets(const ASTRecordLayout &record_layout,
   return true;
 }
 
 bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
                                       uint64_t &alignment,
                                       FieldOffsetMap &field_offsets,
                                       BaseOffsetMap &base_offsets,
                                       BaseOffsetMap &virtual_base_offsets) {
-  ClangASTMetrics::RegisterRecordLayout();
-
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   LLDB_LOGF(log,
             "LayoutRecordType[%u] on (ASTContext*)%p for (RecordDecl*)%p "
             "[name = '%s']",

 }
 
 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
   ClangASTContext *src_ast =
       llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
   if (src_ast == nullptr)
     return CompilerType();
 
-  ClangASTMetrics::RegisterLLDBImport();
-
   SetImportInProgress(true);
 
   QualType copied_qual_type;
 
   if (m_ast_importer_sp) {
     copied_qual_type =
         m_ast_importer_sp->CopyType(m_ast_context, src_ast->getASTContext(),
                                     ClangUtil::GetQualType(src_type));

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

ClangExpressionDeclMap::~ClangExpressionDeclMap() {
   //   that valuable lookup data (like namespaces) doesn't vanish, but
 
   DidParse();
   DisableStructVars();
 }
 
 bool ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
                                        Materializer *materializer) {
-  ClangASTMetrics::ClearLocalCounters();
-
   EnableParserVars();
   m_parser_vars->m_exe_ctx = exe_ctx;
 
   Target *target = exe_ctx.GetTargetPtr();
   if (exe_ctx.GetFramePtr())
     m_parser_vars->m_sym_ctx =
         exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
   else if (exe_ctx.GetThreadPtr() &&

 
 void ClangExpressionDeclMap::InstallCodeGenerator(
     clang::ASTConsumer *code_gen) {
   assert(m_parser_vars);
   m_parser_vars->m_code_gen = code_gen;
 }
 
 void ClangExpressionDeclMap::DidParse() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
-
-  if (log)
-    ClangASTMetrics::DumpCounters(log);
-
   if (m_parser_vars) {
     for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
          entity_index < num_entities; ++entity_index) {
       ExpressionVariableSP var_sp(
           m_found_entities.GetVariableAtIndex(entity_index));
       if (var_sp)
         llvm::cast<ClangExpressionVariable>(var_sp.get())
             ->DisableParserVars(GetParserID());

 }
 
 // Interface for ClangASTSource
 
 void ClangExpressionDeclMap::FindExternalVisibleDecls(
     NameSearchContext &context) {
   assert(m_ast_context);
 
-  ClangASTMetrics::RegisterVisibleQuery();
-
   const ConstString name(context.m_decl_name.getAsString().c_str());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (GetImportInProgress()) {
     if (log && log->GetVerbose())
       LLDB_LOGF(log, "Ignoring a query during an import");
     return;

lldb/source/Symbol/ClangASTImporter.cpp

 #include "clang/Sema/Sema.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <memory>
 
 using namespace lldb_private;
 using namespace clang;
 
-ClangASTMetrics::Counters ClangASTMetrics::global_counters = {0, 0, 0, 0, 0, 0};
-ClangASTMetrics::Counters ClangASTMetrics::local_counters = {0, 0, 0, 0, 0, 0};
-
-void ClangASTMetrics::DumpCounters(Log *log,
-                                   ClangASTMetrics::Counters &counters) {
-  LLDB_LOGF(log, "  Number of visible Decl queries by name     : %" PRIu64,
-            counters.m_visible_query_count);
-  LLDB_LOGF(log, "  Number of lexical Decl queries             : %" PRIu64,
-            counters.m_lexical_query_count);
-  LLDB_LOGF(log, "  Number of imports initiated by LLDB        : %" PRIu64,
-            counters.m_lldb_import_count);
-  LLDB_LOGF(log, "  Number of imports conducted by Clang       : %" PRIu64,
-            counters.m_clang_import_count);
-  LLDB_LOGF(log, "  Number of Decls completed                  : %" PRIu64,
-            counters.m_decls_completed_count);
-  LLDB_LOGF(log, "  Number of records laid out                 : %" PRIu64,
-            counters.m_record_layout_count);
-}
-
-void ClangASTMetrics::DumpCounters(Log *log) {
-  if (!log)
-    return;
-
-  LLDB_LOGF(log, "== ClangASTMetrics output ==");
-  LLDB_LOGF(log, "-- Global metrics --");
-  DumpCounters(log, global_counters);
-  LLDB_LOGF(log, "-- Local metrics --");
-  DumpCounters(log, local_counters);
-}
-
 clang::QualType ClangASTImporter::CopyType(clang::ASTContext *dst_ast,
                                            clang::ASTContext *src_ast,
                                            clang::QualType type) {
   ImporterDelegateSP delegate_sp(GetDelegate(dst_ast, src_ast));
 
   ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp, dst_ast);
 
   if (!delegate_sp)
if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined()) {
       tag_decl->setCompleteDefinition(true);
     }
   } else {
     assert(0 && "CompleteDecl called on a Decl that can't be completed");
   }
 }
 
 bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) {
-  ClangASTMetrics::RegisterDeclCompletion();
-
   DeclOrigin decl_origin = GetDeclOrigin(decl);
 
   if (!decl_origin.Valid())
     return false;
 
   if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&decl->getASTContext(), decl_origin.ctx));
 
   ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp,
                                                 &decl->getASTContext());
   if (delegate_sp)
     delegate_sp->ImportDefinitionTo(decl, decl_origin.decl);
 
   return true;
 }
 
 bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl,
                                                  clang::TagDecl *origin_decl) {
-  ClangASTMetrics::RegisterDeclCompletion();
-
   clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
 
   if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&decl->getASTContext(), origin_ast_ctx));
 
   if (delegate_sp)
     delegate_sp->ImportDefinitionTo(decl, origin_decl);
 
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
 
   OriginMap &origins = context_md->m_origins;
 
   origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
 
   return true;
 }
 
 bool ClangASTImporter::CompleteObjCInterfaceDecl(
     clang::ObjCInterfaceDecl *interface_decl) {
-  ClangASTMetrics::RegisterDeclCompletion();
-
   DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
 
   if (!decl_origin.Valid())
     return false;
 
   if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
     return false;
 
do {
       to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo(
           m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
     } while (false);
   }
 }
 
 void ClangASTImporter::ASTImporterDelegate::Imported(clang::Decl *from,
                                                      clang::Decl *to) {
-  ClangASTMetrics::RegisterClangImport();
-
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   // Some decls shouldn't be tracked here because they were not created by
   // copying 'from' to 'to'. Just exit early for those.
   if (m_decls_to_ignore.find(to) != m_decls_to_ignore.end())
     return clang::ASTImporter::Imported(from, to);
 
   lldb::user_id_t user_id = LLDB_INVALID_UID;