Add a command to dump a module's clang ast.

[zturner]

Summary

This can be useful when diagnosing AST related problems. For example, I had a bug where I was accidentally creating a record type multiple times instead of re-using the first one. This is easy to see with a dump of the AST, because it will look like this:

TranslationUnitDecl 0x18a2bc53b98 <<invalid sloc>> <invalid sloc>
|-CXXRecordDecl 0x18a2bc54458 <<invalid sloc>> <invalid sloc> class ClassWithPadding
|-CXXRecordDecl 0x18a2bc54520 <<invalid sloc>> <invalid sloc> class ClassWithPadding
|-CXXRecordDecl 0x18a2bc545e0 <<invalid sloc>> <invalid sloc> class ClassWithPadding definition
| |-DefinitionData pass_in_registers standard_layout trivially_copyable trivial literal
| | |-DefaultConstructor exists trivial needs_implicit
| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveConstructor exists simple trivial needs_implicit
| | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveAssignment exists simple trivial needs_implicit
| | `-Destructor simple irrelevant trivial needs_implicit
| |-MSInheritanceAttr 0x18a2bc546a0 <<invalid sloc>> Implicit __single_inheritance
| |-FieldDecl 0x18a2bc54748 <<invalid sloc>> <invalid sloc> a 'char'
| |-FieldDecl 0x18a2bc54798 <<invalid sloc>> <invalid sloc> b 'short'
| |-FieldDecl 0x18a2bc54828 <<invalid sloc>> <invalid sloc> c 'char [2]'
| |-FieldDecl 0x18a2bc54878 <<invalid sloc>> <invalid sloc> d 'int'
| |-FieldDecl 0x18a2bc548c8 <<invalid sloc>> <invalid sloc> e 'char'
| |-FieldDecl 0x18a2bc54918 <<invalid sloc>> <invalid sloc> f 'int'
| |-FieldDecl 0x18a2bc54968 <<invalid sloc>> <invalid sloc> g 'long long'
| |-FieldDecl 0x18a2bc549f8 <<invalid sloc>> <invalid sloc> h 'char [3]'
| |-FieldDecl 0x18a2bc54a48 <<invalid sloc>> <invalid sloc> i 'long long'
| |-FieldDecl 0x18a2bc54a98 <<invalid sloc>> <invalid sloc> j 'char [2]'
| |-FieldDecl 0x18a2bc54ae8 <<invalid sloc>> <invalid sloc> k 'long long'
| |-FieldDecl 0x18a2bc54b38 <<invalid sloc>> <invalid sloc> l 'char'
| `-FieldDecl 0x18a2bd96f00 <<invalid sloc>> <invalid sloc> m 'long long'
`-<undeserialized declarations>

Note there are 3 CXXRecordDecls with the same name, but only one definition. Given the complex interactions between debug info and AST reconstruction, a command like this makes problems within the AST very obvious. I found several other AST-related problems, so this was not even the only one, so I think this is a largely unexplored front when it comes to areas for potentially improved test coverage. And since it's in the REPL, it makes it very easy to test out commands in different orders, get a dump, do something else, get another dump, etc to see how the order of commands affects things.

[zturner]

clang dumps to stderr. Only use color if stderr supports this (e.g. if it's not redirected to a file).

[labath]

lldb/source/Commands/CommandObjectTarget.cpp

2275 ↗

(On Diff #172510)

The dump function should take the output stream from the result object, so the output ends up where it's expected to go. (clang::DeclBase::dump has an overload which takes a raw_ostream, and lldb streams have a raw_ostream accessor now).

[zturner]

Unfortunately then color output is impossible. Where else would the output
be expected to go?

[zturner]

Ok so probably this commands output will not go to a log file when logging
is enabled? I can’t think of any other side effects.

Given that the immediate use case for this is interactive investigation and
testing, the first of which is helped by color output and the second of
which doesn’t need logging, what do you think of allowing it as is?

[labath]

In D54072#1286748, @zturner wrote:

Unfortunately then color output is impossible. Where else would the output
be expected to go?

If you execute the command over the SB API (SBCommandInterpreter::HandleCommand) then it will go into the provided result object. Also, some clients (typically IDEs) use SetInput/Output/ErrorFileHandle to set what is considered to be the default input/output streams for a given debugger instance (typically, to redirect these to some console window).

I don't think this directly precludes colored output, although it may require a bit more plumbing to pass the information whether the final consumer is willing to accept color escape codes. (We can already get that via StreamFile->GetFile().GetIsTerminalWithColors(), so you would just need to somehow pass this information to the proxy raw_ostream you give to the clang dump function.)

[zturner]

The issue is that clang writes directly to stderr

[teemperor]

I think Pavel's point is to call the dump overload which allows specifying our own custom raw_ostream: https://clang.llvm.org/doxygen/classclang_1_1Decl.html#a278b3b87b6f9d3b20ed566a8684341a6 And our raw_ostream is configured by LLDB to correctly choose if we want color or not.

[zturner]

I tried that one and it didn’t show color, bit maybe I need to add an
overload of dumpColor that allows to pass a raw_ostream

[teemperor]

Yeah it uses the color settings of the diagnostic engine which are probably set to false in LLDB. I think activating colors there should fix the issue.

[zturner]

So I tried to go down this route, but alas, I still can't come up with a good way to make color output work, because the Stream is not a StreamFile object, it is a StreamString object, even when the output is going to a terminal. We could have an argument such as --color but perhaps it should be the default and the option should be --no-color.

[zturner]

In D54072#1286811, @zturner wrote:

So I tried to go down this route, but alas, I still can't come up with a good way to make color output work, because the Stream is not a StreamFile object, it is a StreamString object, even when the output is going to a terminal. We could have an argument such as --color but perhaps it should be the default and the option should be --no-color.

I tried some more, and yea this is really not easy. The only raw_ostream in LLVM that supports color output is the raw_fd_ostream, so we can't even easily set up the forwarder to support any of this. Even if we configure the diagnostics engine to use color output and pass it the forwarder raw_ostream it still won't work, because it will just call raw_ostream::changeColor which does nothing, since that method is only implemented on raw_fd_ostream.

I'm open to suggestions, but it would be a real shame to not be able to take advantage of the built-in colorization here. Perhaps we can make this a hidden or unsupported command.

[labath]

If it comes down to choosing between colored output going to stderr and plain output going where it should, i'd go with the second option.

The way I'd implement this to support both things is approximately this:

• add color (has_colors, changeColor and friends) support to Stream class, same as llvm::raw_ostream. Apart from solving this problem, this will make the two classes more similar, making eventual llvm transition smoother.
• the raw_ostream shim in the Stream class can just forward the relevant operations
• make the colored-ness of StringStream configurable at construction time. When constructing the StringStream holding the command output, we would look at whether the final output supports colors (Raphael, would that be Debugger.getUseColor()?) or not, and initialize it appropriately.
• as an alternative to previous step, it might be good to check how can look a

It may be more work than you're ready to put into this right now, but it would be very cool nonetheless, as it would unlock colored output for all other commands (and I can think of a couple who could use that).

The downside here is that this would require duplicating the ansi escape sequence code in raw_fd_ostream. However, I believe we already have a code for handling those, so that can hopefully be reused.

[zturner]

I updated the patch to not dump color. We can address the color issue in a followup. So for now it just goes to the result object's output stream. Perhaps we can add a -c option that ignores the result object's outptu stream (and is documented as doing so), but I'll save that for a followup

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

public:
   }
 
   static clang::DeclContext *GetDeclContextForType(clang::QualType type);
 
   static clang::DeclContext *GetDeclContextForType(const CompilerType &type);
 
   uint32_t GetPointerByteSize() override;
 
-  static clang::DeclContext *GetTranslationUnitDecl(clang::ASTContext *ast);
+  static clang::TranslationUnitDecl *
+  GetTranslationUnitDecl(clang::ASTContext *ast);
 
-  clang::DeclContext *GetTranslationUnitDecl() {
+  clang::TranslationUnitDecl *GetTranslationUnitDecl() {
     return GetTranslationUnitDecl(getASTContext());
   }
 
   static clang::Decl *CopyDecl(clang::ASTContext *dest_context,
                                clang::ASTContext *source_context,
                                clang::Decl *source_decl);
 
   static bool AreTypesSame(CompilerType type1, CompilerType type2,
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   // bytes in the "dst" buffer.
   size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
                                    const char *s, uint8_t *dst,
                                    size_t dst_size) override;
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
+  void Dump(Stream &s);
+
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                  Stream *s, lldb::Format format, const DataExtractor &data,
                  lldb::offset_t data_offset, size_t data_byte_size,
                  uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                  bool show_types, bool show_summary, bool verbose,
                  uint32_t depth) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,

lldb/trunk/include/lldb/Symbol/SymbolFile.h

public:
   }
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc) = 0;
   virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
                                         uint32_t line, bool check_inlines,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContextList &sc_list);
+
+  virtual void DumpClangAST(Stream &s) {}
   virtual uint32_t
   FindGlobalVariables(const ConstString &name,
                       const CompilerDeclContext *parent_decl_ctx,
                       uint32_t max_matches, VariableList &variables);
   virtual uint32_t FindGlobalVariables(const RegularExpression &regex,
                                        uint32_t max_matches,
                                        VariableList &variables);
   virtual uint32_t FindFunctions(const ConstString &name,

lldb/trunk/source/Commands/CommandObjectTarget.cpp

if (target == nullptr) {
         result.AppendError("no matching executable images found");
         result.SetStatus(eReturnStatusFailed);
       }
     }
     return result.Succeeded();
   }
 };
 
+#pragma mark CommandObjectTargetModulesDumpSections
+
+//----------------------------------------------------------------------
+// Clang AST dumping command
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesDumpClangAST
+    : public CommandObjectTargetModulesModuleAutoComplete {
+public:
+  CommandObjectTargetModulesDumpClangAST(CommandInterpreter &interpreter)
+      : CommandObjectTargetModulesModuleAutoComplete(
+            interpreter, "target modules dump ast",
+            "Dump the clang ast for a given module's symbol file.",
+            //"target modules dump ast [<file1> ...]")
+            nullptr) {}
+
+  ~CommandObjectTargetModulesDumpClangAST() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+    if (target == nullptr) {
+      result.AppendError("invalid target, create a debug target using the "
+                         "'target create' command");
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    const size_t num_modules = target->GetImages().GetSize();
+    if (num_modules == 0) {
+      result.AppendError("the target has no associated executable images");
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
+    if (command.GetArgumentCount() == 0) {
+      // Dump all ASTs for all modules images
+      result.GetOutputStream().Printf("Dumping clang ast for %" PRIu64
+                                      " modules.\n",
+                                      (uint64_t)num_modules);
+      for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
+        if (m_interpreter.WasInterrupted())
+          break;
+        Module *m = target->GetImages().GetModulePointerAtIndex(image_idx);
+        SymbolFile *sf = m->GetSymbolVendor()->GetSymbolFile();
+        sf->DumpClangAST(result.GetOutputStream());
+      }
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+
+    // Dump specified ASTs (by basename or fullpath)
+    for (const Args::ArgEntry &arg : command.entries()) {
+      ModuleList module_list;
+      const size_t num_matches =
+          FindModulesByName(target, arg.c_str(), module_list, true);
+      if (num_matches == 0) {
+        // Check the global list
+        std::lock_guard<std::recursive_mutex> guard(
+            Module::GetAllocationModuleCollectionMutex());
+
+        result.AppendWarningWithFormat(
+            "Unable to find an image that matches '%s'.\n", arg.c_str());
+        continue;
+      }
+
+      for (size_t i = 0; i < num_matches; ++i) {
+        if (m_interpreter.WasInterrupted())
+          break;
+        Module *m = module_list.GetModulePointerAtIndex(i);
+        SymbolFile *sf = m->GetSymbolVendor()->GetSymbolFile();
+        sf->DumpClangAST(result.GetOutputStream());
+      }
+    }
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return true;
+  }
+};
+
 #pragma mark CommandObjectTargetModulesDumpSymfile
 
 //----------------------------------------------------------------------
 // Image debug symbol dumping command
 //----------------------------------------------------------------------
 
 class CommandObjectTargetModulesDumpSymfile
     : public CommandObjectTargetModulesModuleAutoComplete {

 //----------------------------------------------------------------------
 
 class CommandObjectTargetModulesDump : public CommandObjectMultiword {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   CommandObjectTargetModulesDump(CommandInterpreter &interpreter)
-      : CommandObjectMultiword(interpreter, "target modules dump",
-                               "Commands for dumping information about one or "
-                               "more target modules.",
-                               "target modules dump "
-                               "[headers|symtab|sections|symfile|line-table] "
-                               "[<file1> <file2> ...]") {
+      : CommandObjectMultiword(
+            interpreter, "target modules dump",
+            "[headers|symtab|sections|ast|symfile|line-table] "
     LoadSubCommand("objfile",
                    CommandObjectSP(
                        new CommandObjectTargetModulesDumpObjfile(interpreter)));
     LoadSubCommand(
         "symtab",
         CommandObjectSP(new CommandObjectTargetModulesDumpSymtab(interpreter)));
     LoadSubCommand("sections",
                    CommandObjectSP(new CommandObjectTargetModulesDumpSections(
                        interpreter)));
     LoadSubCommand("symfile",
                    CommandObjectSP(
                        new CommandObjectTargetModulesDumpSymfile(interpreter)));
+    LoadSubCommand(
+        "ast", CommandObjectSP(
+                   new CommandObjectTargetModulesDumpClangAST(interpreter)));
     LoadSubCommand("line-table",
                    CommandObjectSP(new CommandObjectTargetModulesDumpLineTable(
                        interpreter)));
   }
 
   ~CommandObjectTargetModulesDump() override = default;
 };
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
                    const DWARFDIE &die);
 
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
+  void DumpClangAST(lldb_private::Stream &s) override;
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;

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

 // PluginInterface protocol
 //------------------------------------------------------------------
 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
 
 void SymbolFileDWARF::Dump(lldb_private::Stream &s) { m_index->Dump(s); }
 
+void SymbolFileDWARF::DumpClangAST(Stream &s) {
+  TypeSystem *ts = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
+  ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(ts);
+  if (!clang)
+    return;
+  clang->Dump(s);
+}
+
 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
   if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) {
     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
     if (module_sp) {
       SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
       if (sym_vendor)
         m_debug_map_symfile =
             (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

lldb_private::CompilerDeclContext FindNamespace(
       const lldb_private::ConstString &name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
 
+  void DumpClangAST(lldb_private::Stream &s) override;
+
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 protected:

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
 
       return (bool)matching_namespace;
     });
   }
 
   return matching_namespace;
 }
 
+void SymbolFileDWARFDebugMap::DumpClangAST(Stream &s) {
+  ForEachSymbolFile([&s](SymbolFileDWARF *oso_dwarf) -> bool {
+    oso_dwarf->DumpClangAST(s);
+    return true;
+  });
+}
+
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t SymbolFileDWARFDebugMap::GetPluginVersion() { return 1; }

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::PDBFile &GetPDBFile() { return m_index->pdb(); }
   const llvm::pdb::PDBFile &GetPDBFile() const { return m_index->pdb(); }
 
   ClangASTContext &GetASTContext() { return *m_clang; }
   ClangASTImporter &GetASTImporter() { return *m_importer; }
 
+  void DumpClangAST(Stream &s) override;
+
 private:
   size_t FindTypesByName(llvm::StringRef name, uint32_t max_matches,
                          TypeMap &types);
 
   lldb::TypeSP CreateModifierType(PdbSymUid type_uid,
                                   const llvm::codeview::ModifierRecord &mr);
   lldb::TypeSP CreatePointerType(PdbSymUid type_uid,
                                  const llvm::codeview::PointerRecord &pr);

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

bool SymbolFileNativePDB::ParseImportedModules(
   return false;
 }
 
 size_t SymbolFileNativePDB::ParseFunctionBlocks(const SymbolContext &sc) {
   lldbassert(sc.comp_unit && sc.function);
   return 0;
 }
 
+void SymbolFileNativePDB::DumpClangAST(Stream &s) {
+  if (!m_clang)
+    return;
+  m_clang->Dump(s);
+}
+
 uint32_t SymbolFileNativePDB::FindGlobalVariables(
     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, VariableList &variables) {
   using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
 
   std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
       name.GetStringRef(), m_index->symrecords());
   for (const SymbolAndOffset &result : results) {

lldb/trunk/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

clang::DeclContext *PDBASTParser::GetDeclContextContainingSymbol(
   TypeMap types;
   if (auto children_enum =
           global->findChildren(PDB_SymType::None, context, NS_CaseSensitive))
     while (auto child = children_enum->getNext())
       if (auto child_context = GetDeclContextForSymbol(*child))
         return child_context;
 
   // Split context and retrieve nested namespaces
-  auto curr_context = m_ast.GetTranslationUnitDecl();
+  clang::DeclContext *curr_context = m_ast.GetTranslationUnitDecl();
   std::string::size_type from = 0;
   while (from < context_size) {
     auto to = context.find("::", from);
     if (to == std::string::npos)
       to = context_size;
 
     auto namespace_name = context.substr(from, to - from);
     auto namespace_name_c_str = IsAnonymousNamespaceName(namespace_name)

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   llvm::pdb::IPDBSession &GetPDBSession();
 
   const llvm::pdb::IPDBSession &GetPDBSession() const;
 
+  void DumpClangAST(lldb_private::Stream &s) override;
+
 private:
   struct SecContribInfo {
     uint32_t Offset;
     uint32_t Size;
     uint32_t CompilandId;
   };
   using SecContribsMap = std::map<uint32_t, std::vector<SecContribInfo>>;
 

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

uint32_t SymbolFilePDB::FindTypes(
   std::string name_str = name.AsCString();
 
   // There is an assumption 'name' is not a regex
   FindTypesByName(name_str, parent_decl_ctx, max_matches, types);
 
   return types.GetSize();
 }
 
+void SymbolFilePDB::DumpClangAST(Stream &s) {
+  auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  auto clang = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+  if (!clang)
+    return;
+  clang->Dump(s);
+}
+
 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
   // searches or searches across multiple symbol types at the same time, so the
   // best we can do is to search enums, then typedefs, then classes one by one,

lldb/trunk/source/Symbol/ClangASTContext.cpp

CompilerType ClangASTContext::GetCStringType(bool is_const) {
   QualType char_type(ast->CharTy);
 
   if (is_const)
     char_type.addConst();
 
   return CompilerType(ast, ast->getPointerType(char_type));
 }
 
-clang::DeclContext *
+clang::TranslationUnitDecl *
 ClangASTContext::GetTranslationUnitDecl(clang::ASTContext *ast) {
   return ast->getTranslationUnitDecl();
 }
 
 clang::Decl *ClangASTContext::CopyDecl(ASTContext *dst_ast, ASTContext *src_ast,
                                        clang::Decl *source_decl) {
   FileSystemOptions file_system_options;
   FileManager file_manager(file_system_options);
ClangASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
   return 0;
 }
 
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
+void ClangASTContext::Dump(Stream &s) {
+  TranslationUnitDecl *tu = GetTranslationUnitDecl();
+  tu->dump(s.AsRawOstream());
+}
+
 void ClangASTContext::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
     lldb::Format format, const DataExtractor &data,
     lldb::offset_t data_byte_offset, size_t data_byte_size,
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
     bool show_summary, bool verbose, uint32_t depth) {
   if (!type)
     return;