[lldb] Add information on type systems to statistics dump command

[bulbazord]

Summary

Context: I plan on using this change primarily downstream in the apple fork of llvm to track swift module loading time.

The idea is that TypeSystems from modules can self-report statistics when performing the statistics dump of a module.

[bulbazord]

I have a pull request to apple's fork to show how this is used for swift: https://github.com/apple/llvm-project/pull/5540

I primarily wanted this portion to be upstream so that the patch is easier to maintain downstream, but it could be useful for clang-produced TypeSystems as well.

[clayborg]

lldb/source/Target/Statistics.cpp

269–274

Seems like we should be populating module_stat to contain a dictionary of TypeSystem plug-in name to stats. So adding something to the ModuleStats structure like:

std::map<std::string, json::Value> type_system_stats;

Then the loop below would look like:

module->ForEachTypeSystem([&](TypeSystem *ts) {
  if (auto stats = ts->ReportStatistics())
    module_stat. type_system_stats[ts->GetPluginName()] = stats.value();
  return true;
});

We currently don't have each type system reporting a plug-in name, but that would be easy to add to the two TypeSystem plug-ins. ModuleStat::ToJSON() would need to be modified to emit a "typeSystemInfo" only if there are any stats in the "module_stat.type_system_stats" member.

282

Remove {} for single line if statement per llvm coding guidelines

283

We have been doing camel case, but starting with lower case.

[tschuett]

lldb/include/lldb/Core/Module.h

818

Maybe llvm::function_ref?
https://llvm.org/doxygen/classllvm_1_1function__ref_3_01Ret_07Params_8_8_8_08_4.html

[tschuett]

lldb/source/Target/Statistics.cpp

282

I am bit confused. If auto stats is an optional. Please remove .hasValue() and replace stats.getValue by *stats.

[bulbazord]

Address feedback

[clayborg]

Thanks for the changes. Looks good.

[tschuett]

lldb/include/lldb/Core/Module.h

818

Nit: the const &is redundant. It is a function reference.

[bulbazord]

Remove const & from argument to Module::ForEachTypeSystem

lldb/include/lldb/Core/Module.h

 #include "lldb/Utility/UUID.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Chrono.h"
 
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <mutex>
public:
 
   void SetFileSpecAndObjectName(const FileSpec &file, ConstString object_name);
 
   bool GetIsDynamicLinkEditor();
 
   llvm::Expected<TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
+  void ForEachTypeSystem(llvm::function_ref<bool(TypeSystem *)> callback);
+
   // Special error functions that can do printf style formatting that will
   // prepend the message with something appropriate for this module (like the
   // architecture, path and object name (if any)). This centralizes code so
   // that everyone doesn't need to format their error and log messages on their
   // own and keeps the output a bit more consistent.
   void LogMessage(Log *log, const char *format, ...)
       __attribute__((format(printf, 3, 4)));
 

lldb/include/lldb/Symbol/TypeSystem.h

 #include <mutex>
 #include <string>
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
#endif
   // actually idenfiable information to said placeholder. This API allows type
   // systems to tell LLDB when such a type has been encountered In response,
   // the debugger can react by not using this type as a cache entry in any
   // type-specific way For instance, LLDB will currently not cache any
   // formatters that are discovered on such a type as attributable to the
   // meaningless type itself, instead preferring to use the dynamic type
   virtual bool IsMeaninglessWithoutDynamicResolution(void *type);
 
+  virtual llvm::Optional<llvm::json::Value> ReportStatistics();
+
 protected:
   SymbolFile *m_sym_file = nullptr;
 };
 
 class TypeSystemMap {
 public:
   TypeSystemMap();
   ~TypeSystemMap();

lldb/include/lldb/Target/Statistics.h

 //===-- Statistics.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_STATISTICS_H
 #define LLDB_TARGET_STATISTICS_H
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-forward.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/JSON.h"
 #include <atomic>
 #include <chrono>
 #include <ratio>
 #include <string>
 #include <vector>
 
 namespace lldb_private {
struct ModuleStats {
   std::string triple;
   // Path separate debug info file, or empty if none.
   std::string symfile_path;
   // If the debug info is contained in multiple files where each one is
   // represented as a separate lldb_private::Module, then these are the
   // identifiers of these modules in the global module list. This allows us to
   // track down all of the stats that contribute to this module.
   std::vector<intptr_t> symfile_modules;
+  llvm::StringMap<llvm::json::Value> type_system_stats;
   double symtab_parse_time = 0.0;
   double symtab_index_time = 0.0;
   double debug_parse_time = 0.0;
   double debug_index_time = 0.0;
   uint64_t debug_info_size = 0;
   bool symtab_loaded_from_cache = false;
   bool symtab_saved_to_cache = false;
   bool debug_info_index_loaded_from_cache = false;

lldb/source/Core/Module.cpp

void Module::SetUUID(const lldb_private::UUID &uuid) {
   }
 }
 
 llvm::Expected<TypeSystem &>
 Module::GetTypeSystemForLanguage(LanguageType language) {
   return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
 }
 
+void Module::ForEachTypeSystem(
+    llvm::function_ref<bool(TypeSystem *)> callback) {
+  m_type_system_map.ForEach(callback);
+}
+
 void Module::ParseAllDebugSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   size_t num_comp_units = GetNumCompileUnits();
   if (num_comp_units == 0)
     return;
 
   SymbolFile *symbols = GetSymbolFile();
 

lldb/source/Symbol/TypeSystem.cpp

TypeSystem::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
   return std::vector<CompilerDecl>();
 }
 
 std::unique_ptr<UtilityFunction>
 TypeSystem::CreateUtilityFunction(std::string text, std::string name) {
   return {};
 }
 
+llvm::Optional<llvm::json::Value> TypeSystem::ReportStatistics() {
+  return llvm::None;
+}
+
 #pragma mark TypeSystemMap
 
 TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {}
 
 TypeSystemMap::~TypeSystemMap() = default;
 
 void TypeSystemMap::Clear() {
   collection map;

lldb/source/Target/Statistics.cpp

if (!symfile_path.empty())
     module.try_emplace("symbolFilePath", symfile_path);
 
   if (!symfile_modules.empty()) {
     json::Array symfile_ids;
     for (const auto symfile_id: symfile_modules)
       symfile_ids.emplace_back(symfile_id);
     module.try_emplace("symbolFileModuleIdentifiers", std::move(symfile_ids));
   }
+
+  if (!type_system_stats.empty()) {
+    json::Array type_systems;
+    for (const auto &entry : type_system_stats) {
+      json::Object obj;
+      obj.try_emplace(entry.first().str(), entry.second);
+      type_systems.emplace_back(std::move(obj));
+    }
+    module.try_emplace("typeSystemInfo", std::move(type_systems));
+  }
+
   return module;
 }
 
 llvm::json::Value ConstStringStats::ToJSON() const {
   json::Object obj;
   obj.try_emplace<int64_t>("bytesTotal", stats.GetBytesTotal());
   obj.try_emplace<int64_t>("bytesUsed", stats.GetBytesUsed());
   obj.try_emplace<int64_t>("bytesUnused", stats.GetBytesUnused());
if (sym_file) {
         ++num_debug_info_enabled_modules;
       if (module_stat.debug_info_size > 0)
         ++num_modules_has_debug_info;
     }
     symtab_parse_time += module_stat.symtab_parse_time;
     symtab_index_time += module_stat.symtab_index_time;
     debug_parse_time += module_stat.debug_parse_time;
     debug_index_time += module_stat.debug_index_time;
     debug_info_size += module_stat.debug_info_size;
+    module->ForEachTypeSystem([&](TypeSystem *ts) {
+      if (auto stats = ts->ReportStatistics())
+        module_stat.type_system_stats.insert({ts->GetPluginName(), *stats});
+      return true;
+    });
     json_modules.emplace_back(module_stat.ToJSON());
   }
 
   ConstStringStats const_string_stats;
   json::Object json_memory{
       {"strings", const_string_stats.ToJSON()},
   };
 
   json::Object global_stats{
       {"targets", std::move(json_targets)},
       {"modules", std::move(json_modules)},
       {"memory", std::move(json_memory)},
       {"totalSymbolTableParseTime", symtab_parse_time},
       {"totalSymbolTableIndexTime", symtab_index_time},
       {"totalSymbolTablesLoadedFromCache", symtabs_loaded},
       {"totalSymbolTablesSavedToCache", symtabs_saved},
       {"totalDebugInfoParseTime", debug_parse_time},