Report which modules have forcefully completed types in statistics.

[clayborg]

Summary

A previous patch added the ability for us to tell if types were forcefully completed. This patch adds the ability to see which modules have forcefully completed types and aggregates the number of modules with forcefully completed types at the root level.

We add a module specific setting named "debugInfoHadIncompleteTypes" that is a boolean value. We also aggregate the number of modules at the root level that had incomplete debug info with a key named "totalModuleCountWithIncompleteTypes" that is a count of number of modules that had incomplete types.

lldb/include/lldb/Symbol/TypeSystem.h

static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Module *module);
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Target *target);
 
   /// Free up any resources associated with this TypeSystem.  Done before
   /// removing all the TypeSystems from the TypeSystemMap.
   virtual void Finalize() {}
- 
   virtual DWARFASTParser *GetDWARFParser() { return nullptr; }
   virtual PDBASTParser *GetPDBParser() { return nullptr; }
   virtual npdb::PdbAstBuilder *GetNativePDBParser() { return nullptr; }
 
   virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
 
   virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
 
#endif
   // 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();
 
+  bool GetHasForcefullyCompletedTypes() const {
+    return m_has_forcefully_completed_types;
+  }
 protected:
   SymbolFile *m_sym_file = nullptr;
+  /// Used for reporting statistics.
+  bool m_has_forcefully_completed_types = false;
 };
 
 class TypeSystemMap {
 public:
   TypeSystemMap();
   ~TypeSystemMap();
 
   // Clear calls Finalize on all the TypeSystems managed by this map, and then
   // empties the map.
   void Clear();
 
   // Iterate through all of the type systems that are created. Return true from
   // callback to keep iterating, false to stop iterating.
   void ForEach(std::function<bool(lldb::TypeSystemSP)> const &callback);
 
   llvm::Expected<lldb::TypeSystemSP>
   GetTypeSystemForLanguage(lldb::LanguageType language, Module *module,
                            bool can_create);
 
   llvm::Expected<lldb::TypeSystemSP>
   GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
                            bool can_create);
 
+  /// Check all type systems in the map to see if any have forcefully completed
+  /// types;
+  bool GetHasForcefullyCompletedTypes() const;
 protected:
   typedef llvm::DenseMap<uint16_t, lldb::TypeSystemSP> collection;
   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
                               /// multi-threaded environments.
   collection m_map;
   bool m_clear_in_progress = false;
 
 private:

lldb/include/lldb/Target/Statistics.h

struct ModuleStats {
   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;
   bool debug_info_index_saved_to_cache = false;
   bool debug_info_enabled = true;
   bool symtab_stripped = false;
   bool debug_info_had_variable_errors = false;
+  bool debug_info_had_incomplete_types = false;
 };
 
 struct ConstStringStats {
   llvm::json::Value ToJSON() const;
   ConstString::MemoryStats stats = ConstString::GetMemoryStats();
 };
 
 /// A class that represents statistics for a since lldb_private::Target.

lldb/packages/Python/lldbsuite/test/lldbtest.py

 
 # System modules
 import abc
 from distutils.version import LooseVersion
 from functools import wraps
 import gc
 import glob
 import io
+import json
 import os.path
 import re
 import shutil
 import signal
 from subprocess import *
 import sys
 import time
 import traceback
def getLibcPlusPlusLibs(self):
             return ['libc++.1.dylib', 'libc++abi.']
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())
 
+    def get_stats(self, options=None):
+        """
+            Get the output of the "statistics dump" with optional extra options
+            and return the JSON as a python dictionary.
+        """
+        return_obj = lldb.SBCommandReturnObject()
+        command = "statistics dump "
+        if options is not None:
+            command += options
+        self.ci.HandleCommand(command, return_obj, False)
+        metrics_json = return_obj.GetOutput()
+        return json.loads(metrics_json)
+
 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
 # We change the test methods to create a new test method for each test for each debug info we are
 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
 # the new test method we remove the old method at the same time. This functionality can be
 # supressed by at test case level setting the class attribute NO_DEBUG_INFO_TESTCASE or at test
 # level by using the decorator @no_debug_info_test.
 
 
def assertSuccess(self, obj, msg=None):
                 "'{}' is not success".format(error)))
 
     """Assert that a command return object is successful"""
     def assertCommandReturn(self, obj, msg=None):
         if not obj.Succeeded():
             error = obj.GetError()
             self.fail(self._formatMessage(msg,
                 "'{}' is not success".format(error)))
-            
     """Assert two states are equal"""
     def assertState(self, first, second, msg=None):
         if first != second:
             error = "{} ({}) != {} ({})".format(
                 lldbutil.state_type_to_str(first), first,
                 lldbutil.state_type_to_str(second), second)
             self.fail(self._formatMessage(msg, error))
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 static void ForcefullyCompleteType(CompilerType type) {
   bool started = TypeSystemClang::StartTagDeclarationDefinition(type);
   lldbassert(started && "Unable to start a class type definition.");
   TypeSystemClang::CompleteTagDeclarationDefinition(type);
   const clang::TagDecl *td = ClangUtil::GetAsTagDecl(type);
   auto ts_sp = type.GetTypeSystem();
   auto ts = ts_sp.dyn_cast_or_null<TypeSystemClang>();
   if (ts)
-    ts->GetMetadata(td)->SetIsForcefullyCompleted();
+    ts->SetDeclIsForcefullyCompleted(td);
 }
 
 /// This function serves a similar purpose as RequireCompleteType above, but it
 /// avoids completing the type if it is not immediately necessary. It only
 /// ensures we _can_ complete the type later.
 static void PrepareContextToReceiveMembers(TypeSystemClang &ast,
                                            ClangASTImporter &ast_importer,
                                            clang::DeclContext *decl_ctx,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

#endif
   }
 
   /// Complete a type from debug info, or mark it as forcefully completed if
   /// there is no definition of the type in the current Module. Call this
   /// function in contexts where the usual C++ rules require a type to be
   /// complete (base class, member, etc.).
   static void RequireCompleteType(CompilerType type);
 
+  bool SetDeclIsForcefullyCompleted(const clang::TagDecl *td);
+
 private:
   /// Returns the PrintingPolicy used when generating the internal type names.
   /// These type names are mostly used for the formatter selection.
   clang::PrintingPolicy GetTypePrintingPolicy();
   /// Returns the internal type name for the given NamedDecl using the
   /// type printing policy.
   std::string GetTypeNameForDecl(const clang::NamedDecl *named_decl,
                                  bool qualified = true);

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

void TypeSystemClang::RequireCompleteType(CompilerType type) {
   // Since we provide layout assistance, layouts of types containing this class
   // will be correct even if we  are not able to find the definition elsewhere.
   bool started = TypeSystemClang::StartTagDeclarationDefinition(type);
   lldbassert(started && "Unable to start a class type definition.");
   TypeSystemClang::CompleteTagDeclarationDefinition(type);
   const clang::TagDecl *td = ClangUtil::GetAsTagDecl(type);
   auto ts = type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
   if (ts)
-    ts->GetMetadata(td)->SetIsForcefullyCompleted();
+    ts->SetDeclIsForcefullyCompleted(td);
 }
 
 namespace {
 /// A specialized scratch AST used within ScratchTypeSystemClang.
 /// These are the ASTs backing the different IsolatedASTKinds. They behave
 /// like a normal ScratchTypeSystemClang but they don't own their own
 /// persistent  storage or target reference.
 class SpecializedScratchAST : public TypeSystemClang {
if (record_type) {
       assert(record_decl);
       ClangASTMetadata *metadata = GetMetadata(record_decl);
       if (metadata)
         return metadata->IsForcefullyCompleted();
     }
   }
   return false;
 }
+
+bool TypeSystemClang::SetDeclIsForcefullyCompleted(const clang::TagDecl *td) {
+  if (td == nullptr)
+    return false;
+  ClangASTMetadata *metadata = GetMetadata(td);
+  if (metadata == nullptr)
+    return false;
+  m_has_forcefully_completed_types = true;
+  metadata->SetIsForcefullyCompleted();
+  return true;
+}

lldb/source/Target/Statistics.cpp

json::Value ModuleStats::ToJSON() const {
   module.try_emplace("debugInfoByteSize", (int64_t)debug_info_size);
   module.try_emplace("debugInfoIndexLoadedFromCache",
                      debug_info_index_loaded_from_cache);
   module.try_emplace("debugInfoIndexSavedToCache",
                      debug_info_index_saved_to_cache);
   module.try_emplace("debugInfoEnabled", debug_info_enabled);
   module.try_emplace("debugInfoHadVariableErrors",
                      debug_info_had_variable_errors);
+  module.try_emplace("debugInfoHadIncompleteTypes",
+                     debug_info_had_incomplete_types);
   module.try_emplace("symbolTableStripped", symtab_stripped);
   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);
llvm::json::Value DebuggerStats::ReportStatistics(Debugger &debugger,
   }
   std::vector<ModuleStats> modules;
   std::lock_guard<std::recursive_mutex> guard(
       Module::GetAllocationModuleCollectionMutex());
   const uint64_t num_modules = Module::GetNumberAllocatedModules();
   uint32_t num_debug_info_enabled_modules = 0;
   uint32_t num_modules_has_debug_info = 0;
   uint32_t num_modules_with_variable_errors = 0;
+  uint32_t num_modules_with_incomplete_types = 0;
   uint32_t num_stripped_modules = 0;
   for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
     Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
     ModuleStats module_stat;
     module_stat.identifier = (intptr_t)module;
     module_stat.path = module->GetFileSpec().GetPath();
     if (ConstString object_name = module->GetObjectName()) {
       module_stat.path.append(1, '(');
for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
     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([&](lldb::TypeSystemSP ts) {
       if (auto stats = ts->ReportStatistics())
         module_stat.type_system_stats.insert({ts->GetPluginName(), *stats});
+      if (ts->GetHasForcefullyCompletedTypes())
+        module_stat.debug_info_had_incomplete_types = true;
       return true;
     });
+    if (module_stat.debug_info_had_incomplete_types)
+      ++num_modules_with_incomplete_types;
+
     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},
       {"totalDebugInfoIndexTime", debug_index_time},
       {"totalDebugInfoIndexLoadedFromCache", debug_index_loaded},
       {"totalDebugInfoIndexSavedToCache", debug_index_saved},
       {"totalDebugInfoByteSize", debug_info_size},
       {"totalModuleCount", num_modules},
       {"totalModuleCountHasDebugInfo", num_modules_has_debug_info},
       {"totalModuleCountWithVariableErrors", num_modules_with_variable_errors},
+      {"totalModuleCountWithIncompleteTypes", num_modules_with_incomplete_types},
       {"totalDebugInfoEnabled", num_debug_info_enabled_modules},
       {"totalSymbolTableStripped", num_stripped_modules},
   };
   return std::move(global_stats);
 }

lldb/test/API/commands/statistics/basic/TestStats.py

class TestCase(TestBase):
     def verify_success_fail_count(self, stats, key, num_successes, num_fails):
         self.verify_key_in_dict(key, stats, 'stats["%s"]' % (key))
         success_fail_dict = stats[key]
         self.assertEqual(success_fail_dict['successes'], num_successes,
                          'make sure success count')
         self.assertEqual(success_fail_dict['failures'], num_fails,
                          'make sure success count')
 
-    def get_stats(self, options=None, log_path=None):
-        """
-            Get the output of the "statistics dump" with optional extra options
-            and return the JSON as a python dictionary.
-        """
-        # If log_path is set, open the path and emit the output of the command
-        # for debugging purposes.
-        if log_path is not None:
-            f = open(log_path, 'w')
-        else:
-            f = None
-        return_obj = lldb.SBCommandReturnObject()
-        command = "statistics dump "
-        if options is not None:
-            command += options
-        if f:
-            f.write('(lldb) %s\n' % (command))
-        self.ci.HandleCommand(command, return_obj, False)
-        metrics_json = return_obj.GetOutput()
-        if f:
-            f.write(metrics_json)
-        return json.loads(metrics_json)
-
-
     def get_target_stats(self, debug_stats):
         if "targets" in debug_stats:
             return debug_stats["targets"][0]
         return None
 
     def test_expressions_frame_var_counts(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here",
def test_no_dsym_binary_has_symfile_identifiers_in_stats(self):
             info, but verify that the .o files have debug info size that is
             greater than zero. This test ensures that we don't double count
             debug info.
         """
         self.build(debug_info="dwarf")
         exe_name = 'a.out'
         exe = self.getBuildArtifact(exe_name)
         dsym = self.getBuildArtifact(exe_name + ".dSYM")
-        print("carp: dsym = '%s'" % (dsym))
         # Make sure the executable file exists after building.
         self.assertEqual(os.path.exists(exe), True)
         # Make sure the dSYM file doesn't exist after building.
         self.assertEqual(os.path.isdir(dsym), False)
 
         # Create the target
         target = self.createTestTarget(file_path=exe)
 
def test_had_frame_variable_errors(self):
             Test that if we have frame variable errors that we see this in the
             statistics for the module that had issues.
         """
         self.build(debug_info="dwarf")
         exe_name = 'a.out'
         exe = self.getBuildArtifact(exe_name)
         dsym = self.getBuildArtifact(exe_name + ".dSYM")
         main_obj = self.getBuildArtifact('main.o')
-        print("carp: dsym = '%s'" % (dsym))
         # Make sure the executable file exists after building.
         self.assertEqual(os.path.exists(exe), True)
         # Make sure the dSYM file doesn't exist after building.
         self.assertEqual(os.path.isdir(dsym), False)
         # Make sure the main.o object file exists after building.
         self.assertEqual(os.path.exists(main_obj), True)
 
         # Delete the main.o file that contains the debug info so we force an

lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py

class LimitDebugInfoTestCase(TestBase):
 
     def _check_debug_info_is_limited(self, target):
         # Without other shared libraries we should only see the member declared
         # in the derived class. This serves as a sanity check that we are truly
         # building with limited debug info.
         self._check_type(target, "InheritsFromOne")
         self._check_type(target, "InheritsFromTwo")
 
+        # Check that the statistics show that we had incomplete debug info.
+        stats = self.get_stats()
+        # Find the a.out module info in the stats and verify it has the
+        # "debugInfoHadIncompleteTypes" key value pair set to True
+        exe_module_found = False
+        for module in stats['modules']:
+            if module['path'].endswith('a.out'):
+                self.assertTrue(module['debugInfoHadIncompleteTypes'])
+                exe_module_found = True
+                break
+        self.assertTrue(exe_module_found)
+        # Verify that "totalModuleCountWithIncompleteTypes" at the top level
+        # is greater than zero which shows we had incomplete debug info in a
+        # module
+        self.assertGreater(stats['totalModuleCountWithIncompleteTypes'], 0)
+
+
     def _check_incomplete_frame_variable_output(self):
         # Check that the display of the "frame variable" output identifies the
         # incomplete types. Currently the expression parser will find the real
         # definition for a type when running an expression for any forcefully
         # completed types, but "frame variable" won't. I hope to fix this with
         # a follow up patch, but if we don't find the actual definition we
         # should clearly show this to the user by showing which types were
         # incomplete. So this will test verifies the expected output for such