[lldb] Allow dumping the state of all scratch TypeSystems

[teemperor]

Summary

This adds the target dump typesystem'command which dumps the TypeSystem of the
target itself (aka the 'scratch TypeSystem'). This is similar to target modules dump ast
which dumps the AST of lldb::Modules associated with a selected target.

Unlike target modules dump ast, the new command is not a subcommand of
target modules dump as it's not touching the modules of a target at all. Also unlike
target modules dump ast I tried to keep the implementation language-neutral, so
this patch moves our Clang Dump to the TypeSystem interface so it will also dump
the state of any future/downstream scratch TypeSystems (e.g., Swift). That's also
why the command just refers to a 'typesystem' instead of an 'ast' (which is only how
Clang is necessarily modelling the internal TypeSystem state).

The main motivation for this patch is that I need to write some tests that check
for duplicates in the ScratchTypeSystemClang of a target. There is currently no way
to check for this at the moment (beside measuring memory consumption of course).
It's probably also useful for debugging LLDB itself.

[labath]

Does it make sense to make target modules dump ast use the new DumpState method?

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

9751

use static instead of anonymous namesapce

[teemperor]

• Repurpose existing Dump method.

[teemperor]

In D111936#3069360, @labath wrote:

Does it make sense to make target modules dump ast use the new DumpState method?

Makes sense, I repurposed the existing non-virtual Dump so both should use the same backend.

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

9751

whops, thanks!

lldb/include/lldb/Symbol/TypeSystem.h

#endif
   /// Print a description of the type to a stream. The exact implementation
   /// varies, but the expectation is that eDescriptionLevelFull returns a
   /// source-like representation of the type, whereas eDescriptionLevelVerbose
   /// does a dump of the underlying AST if applicable.
   virtual void DumpTypeDescription(
       lldb::opaque_compiler_type_t type, Stream *s,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
 
+  /// Dump a textual representation of the internal TypeSystem state to the
+  /// given stream.
+  ///
+  /// This should not modify the state of the TypeSystem if possible.
+  virtual void Dump(llvm::raw_ostream &output) = 0;
+
   // TODO: These methods appear unused. Should they be removed?
 
   virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) = 0;
 
   virtual void DumpSummary(lldb::opaque_compiler_type_t type,
                            ExecutionContext *exe_ctx, Stream *s,
                            const DataExtractor &data,
                            lldb::offset_t data_offset,

lldb/source/Commands/CommandObjectTarget.cpp

LoadSubCommand("enable",
                        "Enable a stop-hook.", "target stop-hook enable")));
     LoadSubCommand("list", CommandObjectSP(new CommandObjectTargetStopHookList(
                                interpreter)));
   }
 
   ~CommandObjectMultiwordTargetStopHooks() override = default;
 };
 
+#pragma mark CommandObjectTargetDumpTypesystem
+
+/// Dumps the TypeSystem of the selected Target.
+class CommandObjectTargetDumpTypesystem : public CommandObjectParsed {
+public:
+  CommandObjectTargetDumpTypesystem(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "target dump typesystem",
+            "Dump the state of the target's internal type system.\n"
+            "Intended to be used for debugging LLDB itself.",
+            nullptr, eCommandRequiresTarget) {}
+
+  ~CommandObjectTargetDumpTypesystem() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!command.empty()) {
+      result.AppendError("target dump typesystem doesn't take arguments.");
+      return result.Succeeded();
+    }
+
+    // Go over every scratch TypeSystem and dump to the command output.
+    for (TypeSystem *ts : GetSelectedTarget().GetScratchTypeSystems())
+      ts->Dump(result.GetOutputStream().AsRawOstream());
+
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return result.Succeeded();
+  }
+};
+
+#pragma mark CommandObjectTargetDump
+
+/// Multi-word command for 'target dump'.
+class CommandObjectTargetDump : public CommandObjectMultiword {
+public:
+  // Constructors and Destructors
+  CommandObjectTargetDump(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "target dump",
+            "Commands for dumping information about the target.",
+            "target dump [typesystem]") {
+    LoadSubCommand(
+        "typesystem",
+        CommandObjectSP(new CommandObjectTargetDumpTypesystem(interpreter)));
+  }
+
+  ~CommandObjectTargetDump() override = default;
+};
+
 #pragma mark CommandObjectMultiwordTarget
 
 // CommandObjectMultiwordTarget
 
 CommandObjectMultiwordTarget::CommandObjectMultiwordTarget(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "target",
                              "Commands for operating on debugger targets.",
                              "target <subcommand> [<subcommand-options>]") {
   LoadSubCommand("create",
                  CommandObjectSP(new CommandObjectTargetCreate(interpreter)));
   LoadSubCommand("delete",
                  CommandObjectSP(new CommandObjectTargetDelete(interpreter)));
+  LoadSubCommand("dump",
+                 CommandObjectSP(new CommandObjectTargetDump(interpreter)));
   LoadSubCommand("list",
                  CommandObjectSP(new CommandObjectTargetList(interpreter)));
   LoadSubCommand("select",
                  CommandObjectSP(new CommandObjectTargetSelect(interpreter)));
   LoadSubCommand("show-launch-environment",
                  CommandObjectSP(new CommandObjectTargetShowLaunchEnvironment(
                      interpreter)));
   LoadSubCommand(

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

 void SymbolFileDWARF::DumpClangAST(Stream &s) {
   auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
   if (!ts_or_err)
     return;
   TypeSystemClang *clang =
       llvm::dyn_cast_or_null<TypeSystemClang>(&ts_or_err.get());
   if (!clang)
     return;
-  clang->Dump(s);
+  clang->Dump(s.AsRawOstream());
 }
 
 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
   if (m_debug_map_symfile == nullptr) {
     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
     if (module_sp) {
       m_debug_map_symfile =
           static_cast<SymbolFileDWARFDebugMap *>(module_sp->GetSymbolFile());

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

clang::Decl * PdbAstBuilder::FromCompilerDecl(CompilerDecl decl) {
   return ClangUtil::GetDecl(decl);
 }
 
 clang::DeclContext *
 PdbAstBuilder::FromCompilerDeclContext(CompilerDeclContext context) {
   return static_cast<clang::DeclContext *>(context.GetOpaqueDeclContext());
 }
 
-void PdbAstBuilder::Dump(Stream &stream) { m_clang.Dump(stream); }
+void PdbAstBuilder::Dump(Stream &stream) {
+  m_clang.Dump(stream.AsRawOstream());
+}

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to dump ClangAST");
     return;
   }
 
   auto *clang_type_system =
       llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
   if (!clang_type_system)
     return;
-  clang_type_system->Dump(s);
+  clang_type_system->Dump(s.AsRawOstream());
 }
 
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
   // When searching by regex, we need to go out of our way to limit the search
   // space as much as possible since this searches EVERYTHING in the PDB,
   // manually doing regex comparisons.  PDB library isn't optimized for regex

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

#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   // Dumping types
 #ifndef NDEBUG
   /// Convenience LLVM-style dump method for use in the debugger only.
   /// In contrast to the other \p Dump() methods this directly invokes
   /// \p clang::QualType::dump().
   LLVM_DUMP_METHOD void dump(lldb::opaque_compiler_type_t type) const override;
 #endif
 
-  void Dump(Stream &s);
+  /// \see lldb_private::TypeSystem::Dump
+  void Dump(llvm::raw_ostream &output) override;
 
   /// Dump clang AST types from the symbol file.
   ///
   /// \param[in] s
   ///       A stream to send the dumped AST node(s) to
   /// \param[in] symbol_name
   ///       The name of the symbol to dump, if it is empty dump all the symbols
   void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name);
public:
   /// \param lang_opts The LangOptions of a clang ASTContext that the caller
   ///                  wants to export type information from. This is used to
   ///                  find the best matching sub-AST that will be returned.
   static TypeSystemClang *GetForTarget(Target &target,
                                        const clang::LangOptions &lang_opts) {
     return GetForTarget(target, InferIsolatedASTKindFromLangOpts(lang_opts));
   }
 
+  /// \see lldb_private::TypeSystem::Dump
+  void Dump(llvm::raw_ostream &output) override;
+
   UserExpression *
   GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix,
                     lldb::LanguageType language,
                     Expression::ResultType desired_type,
                     const EvaluateExpressionOptions &options,
                     ValueObject *ctx_obj) override;
 
   FunctionCaller *GetFunctionCaller(const CompilerType &return_type,

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

 TypeSystemClang::dump(lldb::opaque_compiler_type_t type) const {
   if (!type)
     return;
   clang::QualType qual_type(GetQualType(type));
   qual_type.dump();
 }
 #endif
 
-void TypeSystemClang::Dump(Stream &s) {
-  Decl *tu = Decl::castFromDeclContext(GetTranslationUnitDecl());
-  tu->dump(s.AsRawOstream());
+void TypeSystemClang::Dump(llvm::raw_ostream &output) {
+  GetTranslationUnitDecl()->dump(output);
 }
 
 void TypeSystemClang::DumpFromSymbolFile(Stream &s,
                                          llvm::StringRef symbol_name) {
   SymbolFile *symfile = GetSymbolFile();
 
   if (!symfile)
     return;
ScratchTypeSystemClang &scratch_ast =
       llvm::cast<ScratchTypeSystemClang>(type_system_or_err.get());
   // If no dedicated sub-AST was requested, just return the main AST.
   if (ast_kind == DefaultAST)
     return &scratch_ast;
   // Search the sub-ASTs.
   return &scratch_ast.GetIsolatedAST(*ast_kind);
 }
 
+/// Returns a human-readable name that uniquely identifiers the sub-AST kind.
+static llvm::StringRef
+GetNameForIsolatedASTKind(ScratchTypeSystemClang::IsolatedASTKind kind) {
+  switch (kind) {
+  case ScratchTypeSystemClang::IsolatedASTKind::CppModules:
+    return "C++ modules";
+  }
+  llvm_unreachable("Unimplemented IsolatedASTKind?");
+}
+
+void ScratchTypeSystemClang::Dump(llvm::raw_ostream &output) {
+  // First dump the main scratch AST.
+  output << "State of scratch Clang type system:\n";
+  TypeSystemClang::Dump(output);
+
+  // Now sort the isolated sub-ASTs.
+  typedef std::pair<IsolatedASTKey, TypeSystem *> KeyAndTS;
+  std::vector<KeyAndTS> sorted_typesystems;
+  for (const auto &a : m_isolated_asts)
+    sorted_typesystems.emplace_back(a.first, a.second.get());
+  llvm::stable_sort(sorted_typesystems,
+                    [](const KeyAndTS &lhs, const KeyAndTS &rhs) {
+                      return lhs.first < rhs.first;
+                    });
+
+  // Dump each sub-AST too.
+  for (const auto &a : sorted_typesystems) {
+    IsolatedASTKind kind =
+        static_cast<ScratchTypeSystemClang::IsolatedASTKind>(a.first);
+    output << "State of scratch Clang type subsystem "
+           << GetNameForIsolatedASTKind(kind) << ":\n";
+    a.second->Dump(output);
+  }
+}
+
 UserExpression *ScratchTypeSystemClang::GetUserExpression(
     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
     Expression::ResultType desired_type,
     const EvaluateExpressionOptions &options, ValueObject *ctx_obj) {
   TargetSP target_sp = m_target_wp.lock();
   if (!target_sp)
     return nullptr;
 

lldb/test/API/commands/target/dump/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/target/dump/TestTargetDumpTypeSystem.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_dumping(self):
+        """ Tests dumping an empty and non-empty scratch AST. """
+        self.build()
+        self.createTestTarget()
+
+        # Make sure DummyStruct is not in the scratch AST by default.
+        self.expect("target dump typesystem", matching=False, substrs=["struct DummyStruct"])
+
+        # Move DummyStruct into the scratch AST via the expression evaluator.
+        # FIXME: Once there is an SB API for using variable paths on globals
+        # then this should be done this way.
+        self.expect_expr("s", result_type="DummyStruct")
+
+        # Dump the scratch AST and make sure DummyStruct is in there.
+        self.expect("target dump typesystem", substrs=["struct DummyStruct"])
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        """ Test an invalid invocation on 'target dump typesystem'. """
+        self.build()
+        self.createTestTarget()
+        self.expect("target dump typesystem arg", error=True,
+                    substrs=["error: target dump typesystem doesn't take arguments."])

lldb/test/API/commands/target/dump/main.cpp

+struct DummyStruct {
+  int i;
+};
+
+DummyStruct s;
+
+int main() { return s.i; }