Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt
+++ test/CMakeLists.txt
@@ -54,6 +54,7 @@
   clang-rename
   clang-refactor
   clang-diff
+  clang-doc
   )
   
 if(CLANG_ENABLE_STATIC_ANALYZER)
Index: test/Tooling/clang-doc-basic.cpp
===================================================================
--- /dev/null
+++ test/Tooling/clang-doc-basic.cpp
@@ -0,0 +1,83 @@
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: echo '[{"directory":"%t","command":"clang++ -c %t/test.cpp","file":"%t/test.cpp"}]' | sed -e 's/\\/\//g' > %t/compile_commands.json
+// RUN: cp "%s" "%t/test.cpp"
+// RUN: clang-doc -p %t %t/test.cpp | FileCheck %s -DROOT=%t --implicit-check-not Skipping
+
+/// Test namespace
+namespace A {
+  
+/// A function
+void f(int x) {}
+
+} // end namespace A
+
+/// A C++ class
+class C {
+private:
+  int i;
+};
+
+// CHECK-DAG: Parsing codebase...
+// CHECK-DAG: Writing docs...
+// CHECK-DAG: ---
+// CHECK-DAG: Files:           
+// CHECK-DAG:   - Filename:        [[ROOT]]/test.cpp
+// CHECK-DAG:     Description:     
+// CHECK-DAG:       Kind:            ''
+// CHECK-DAG: Namespaces:      
+// CHECK-DAG:   - Qualified Name:  ''
+// CHECK-DAG:     Name:            ''
+// CHECK-DAG:     Namespace:       ''
+// CHECK-DAG:   - Qualified Name:  A
+// CHECK-DAG:     Name:            A
+// CHECK-DAG:     Namespace:       ''
+// CHECK-DAG:     Descriptions:    
+// CHECK-DAG:       - Kind:            FullComment
+// CHECK-DAG:         Children:        
+// CHECK-DAG:           - Kind:            ParagraphComment
+// CHECK-DAG:             Children:        
+// CHECK-DAG:               - Kind:            TextComment
+// CHECK-DAG:                 Text:            ' Test namespace'
+// CHECK-DAG:     Locations:       
+// CHECK-DAG:       - LineNumber:      8
+// CHECK-DAG:         Filename:        [[ROOT]]/test.cpp
+// CHECK-DAG:     Functions:       
+// CHECK-DAG:       - Mangled Name:    _ZN1A1fEi
+// CHECK-DAG:         Qualified Name:  'A::f'
+// CHECK-DAG:         Name:            f
+// CHECK-DAG:         Namespace:       A
+// CHECK-DAG:         Descriptions:    
+// CHECK-DAG:           - Kind:            FullComment
+// CHECK-DAG:             Children:        
+// CHECK-DAG:               - Kind:            ParagraphComment
+// CHECK-DAG:                 Children:        
+// CHECK-DAG:                   - Kind:            TextComment
+// CHECK-DAG:                     Text:            ' A function'
+// CHECK-DAG:         Locations:       
+// CHECK-DAG:           - LineNumber:      11
+// CHECK-DAG:             Filename:        [[ROOT]]/test.cpp
+// CHECK-DAG:         DefinitionFile:  [[ROOT]]/test.cpp
+// CHECK-DAG:         ReturnType:      void
+// CHECK-DAG:         Access:          None
+// CHECK-DAG: Types:           
+// CHECK-DAG:   - Qualified Name:  C
+// CHECK-DAG:     Name:            C
+// CHECK-DAG:     Namespace:       ''
+// CHECK-DAG:     Descriptions:    
+// CHECK-DAG:       - Kind:            FullComment
+// CHECK-DAG:         Children:        
+// CHECK-DAG:           - Kind:            ParagraphComment
+// CHECK-DAG:             Children:        
+// CHECK-DAG:               - Kind:            TextComment
+// CHECK-DAG:                 Text:            ' A C++ class'
+// CHECK-DAG:     TagType:         Class
+// CHECK-DAG:     Locations:       
+// CHECK-DAG:       - LineNumber:      16
+// CHECK-DAG:         Filename:        [[ROOT]]/test.cpp
+// CHECK-DAG:     DefinitionFile:  [[ROOT]]/test.cpp
+// CHECK-DAG:     Members:         
+// CHECK-DAG:       - Type:            int
+// CHECK-DAG:         Name:            'C::i'
+// CHECK-DAG:         Access:          None
+// CHECK-DAG: ...
Index: test/lit.cfg.py
===================================================================
--- test/lit.cfg.py
+++ test/lit.cfg.py
@@ -57,9 +57,9 @@
 tool_dirs = [config.clang_tools_dir, config.llvm_tools_dir]
 
 tools = [
-    'c-index-test', 'clang-check', 'clang-diff', 'clang-format', 'opt',
-    ToolSubst('%clang_func_map', command=FindTool(
-        'clang-func-mapping'), unresolved='ignore'),
+    'c-index-test', 'clang-check', 'clang-diff', 'clang-doc', 'clang-format', 
+    'opt', ToolSubst('%clang_func_map', command=FindTool(
+            'clang-func-mapping'), unresolved='ignore'),
 ]
 
 if config.clang_examples:
Index: tools/CMakeLists.txt
===================================================================
--- tools/CMakeLists.txt
+++ tools/CMakeLists.txt
@@ -3,6 +3,7 @@
 add_clang_subdirectory(diagtool)
 add_clang_subdirectory(driver)
 add_clang_subdirectory(clang-diff)
+add_clang_subdirectory(clang-doc)
 add_clang_subdirectory(clang-format)
 add_clang_subdirectory(clang-format-vs)
 add_clang_subdirectory(clang-fuzzer)
Index: tools/clang-doc/CMakeLists.txt
===================================================================
--- /dev/null
+++ tools/clang-doc/CMakeLists.txt
@@ -0,0 +1,21 @@
+set(LLVM_LINK_COMPONENTS
+  support
+  )
+
+add_clang_library(clangDoc
+  ClangDoc.cpp
+  ClangDocReporter.cpp
+
+  LINK_LIBS
+  clangAnalysis
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangFormat
+  clangFrontend
+  clangLex
+  clangTooling
+  clangToolingCore
+  )
+
+add_subdirectory(tool)
Index: tools/clang-doc/ClangDoc.h
===================================================================
--- /dev/null
+++ tools/clang-doc/ClangDoc.h
@@ -0,0 +1,97 @@
+//===-- ClangDoc.cpp - ClangDoc ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H
+
+#include "ClangDocReporter.h"
+#include "clang/AST/AST.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/ASTConsumers.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Tooling/Tooling.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace doc {
+
+// A Context which contains extra options which are used in ClangMoveTool.
+struct ClangDocContext {
+  // Which format in which to emit representation.
+  OutFormat EmitFormat;
+};
+
+class ClangDocVisitor : public RecursiveASTVisitor<ClangDocVisitor> {
+public:
+  explicit ClangDocVisitor(ASTContext *Ctx, ClangDocReporter &Reporter)
+      : Context(Ctx), Manager(Ctx->getSourceManager()),
+        MC(Ctx->createMangleContext()), Reporter(Reporter) {}
+
+  bool VisitTagDecl(const TagDecl *D);
+  bool VisitNamespaceDecl(const NamespaceDecl *D);
+  bool VisitFunctionDecl(const FunctionDecl *D);
+  void parseUnattachedComments();
+
+private:
+  bool isUnparsed(SourceLocation Loc) const;
+  int getLine(const Decl *D) const;
+  std::string getFile(const Decl *D) const;
+  comments::FullComment* getComment(const Decl *D);
+  std::string mangleName(const FunctionDecl *D);
+
+  ASTContext *Context;
+  SourceManager &Manager;
+  MangleContext *MC;
+  ClangDocReporter &Reporter;
+};
+
+class ClangDocConsumer : public clang::ASTConsumer {
+public:
+  explicit ClangDocConsumer(ASTContext *Ctx, ClangDocReporter &Reporter)
+      : Visitor(Ctx, Reporter), Reporter(Reporter) {}
+
+  virtual void HandleTranslationUnit(clang::ASTContext &Context);
+
+private:
+  ClangDocVisitor Visitor;
+  ClangDocReporter &Reporter;
+};
+
+class ClangDocAction : public clang::ASTFrontendAction {
+public:
+  ClangDocAction(ClangDocReporter &Reporter) : Reporter(Reporter) {}
+
+  virtual std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &C, llvm::StringRef InFile);
+
+private:
+  ClangDocReporter &Reporter;
+};
+
+class ClangDocActionFactory : public tooling::FrontendActionFactory {
+public:
+  ClangDocActionFactory(ClangDocContext &Ctx, ClangDocReporter &Reporter)
+      : Context(Ctx), Reporter(Reporter) {}
+
+  clang::FrontendAction *create() override {
+    return new ClangDocAction(Reporter);
+  }
+
+private:
+  ClangDocContext &Context;
+  ClangDocReporter &Reporter;
+};
+
+} // namespace doc
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H
Index: tools/clang-doc/ClangDoc.cpp
===================================================================
--- /dev/null
+++ tools/clang-doc/ClangDoc.cpp
@@ -0,0 +1,127 @@
+//===-- ClangDoc.cpp - ClangDoc ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangDoc.h"
+#include "clang/AST/Comment.h"
+#include "clang/AST/Mangle.h"
+#include "clang/Frontend/CompilerInstance.h"
+
+using namespace clang;
+using namespace clang::tooling;
+using namespace llvm;
+
+namespace clang {
+namespace doc {
+
+bool ClangDocVisitor::VisitTagDecl(const TagDecl *D) {
+  if (!isUnparsed(D->getLocation()))
+    return true;
+
+  if (const auto *E = dyn_cast<EnumDecl>(D)) {
+    Reporter.createEnumInfo(E, getComment(E), getLine(E), getFile(E));
+    return true;
+  }
+  if (const auto *R = dyn_cast<RecordDecl>(D)) {
+    Reporter.createTypeInfo(R, getComment(R), getLine(R), getFile(R));
+    return true;
+  }
+  
+  // Error?
+  return true;
+}
+
+bool ClangDocVisitor::VisitNamespaceDecl(const NamespaceDecl *D) {
+  if (!isUnparsed(D->getLocation()))
+    return true;
+  Reporter.createNamespaceInfo(D, getComment(D), getLine(D), getFile(D));
+  return true;
+}
+
+bool ClangDocVisitor::VisitFunctionDecl(const FunctionDecl *D) {
+  if (!isUnparsed(D->getLocation()))
+    return true;
+  if (const auto *C = dyn_cast<CXXMethodDecl>(D)) {
+    Reporter.createMethodInfo(C, getComment(C), getLine(C), getFile(C), 
+                                  mangleName(C));
+    return true;
+  }
+  
+  Reporter.createFunctionInfo(D, getComment(D), getLine(D), getFile(D), 
+                                mangleName(D));
+  return true;
+}
+
+comments::FullComment *ClangDocVisitor::getComment(const Decl *D) {
+  RawComment *Comment = Context->getRawCommentForDeclNoCache(D);
+
+  // FIXME: Move setAttached to the initial comment parsing.
+  if (Comment) {
+    Comment->setAttached();
+    return Comment->parse(*Context, nullptr, D);
+  }
+  return nullptr;
+}
+
+int ClangDocVisitor::getLine(const Decl *D) const {
+  PresumedLoc PLoc = Manager.getPresumedLoc(D->getLocStart());
+  return PLoc.getLine();
+}
+
+std::string ClangDocVisitor::getFile(const Decl *D) const {
+  PresumedLoc PLoc = Manager.getPresumedLoc(D->getLocStart());
+  return PLoc.getFilename();
+}
+
+void ClangDocVisitor::parseUnattachedComments() {
+  for (RawComment *Comment : Context->getRawCommentList().getComments()) {
+    if (!isUnparsed(Comment->getLocStart()) || Comment->isAttached())
+      continue;
+    CommentInfo CI;
+    Reporter.parseFullComment(Comment->parse(*Context, nullptr, nullptr), CI);
+    Reporter.addUnattachedComment(Manager.getFilename(Comment->getLocStart()),
+                                  CI);
+  }
+}
+
+bool ClangDocVisitor::isUnparsed(SourceLocation Loc) const {
+  if (!Loc.isValid())
+    return false;
+  const std::string &Filename = Manager.getFilename(Loc);
+
+  if (!Reporter.hasFile(Filename))
+    return false;
+  if (Manager.isInSystemHeader(Loc) || Manager.isInExternCSystemHeader(Loc))
+    return false;
+  return true;
+}
+
+std::string ClangDocVisitor::mangleName(const FunctionDecl *D) {
+  std::string S;
+  llvm::raw_string_ostream MangledName(S);
+  if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(D))
+    MC->mangleCXXCtor(Ctor, CXXCtorType::Ctor_Complete, MangledName);
+  else if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
+    MC->mangleCXXDtor(Dtor, CXXDtorType::Dtor_Complete, MangledName);
+  else
+    MC->mangleName(D, MangledName);
+  return MangledName.str();
+}
+
+void ClangDocConsumer::HandleTranslationUnit(ASTContext &Context) {
+  Visitor.TraverseDecl(Context.getTranslationUnitDecl());
+  Visitor.parseUnattachedComments();
+}
+
+std::unique_ptr<ASTConsumer>
+ClangDocAction::CreateASTConsumer(CompilerInstance &C, StringRef InFile) {
+  return make_unique<ClangDocConsumer>(&C.getASTContext(), Reporter);
+}
+
+} // namespace doc
+} // namespace clang
Index: tools/clang-doc/ClangDocReporter.h
===================================================================
--- /dev/null
+++ tools/clang-doc/ClangDocReporter.h
@@ -0,0 +1,190 @@
+//===-- Doc.cpp - ClangDoc --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_REPORTER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_REPORTER_H
+
+#include "clang/AST/AST.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/CommentVisitor.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/ASTConsumers.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace clang::comments;
+
+namespace clang {
+namespace doc {
+
+enum class OutFormat { YAML, LLVM };
+
+// Info for named types (parameters, members).
+struct NamedType {
+  std::string Type;
+  std::string Name;
+  AccessSpecifier Access;
+};
+
+struct Location {
+  int LineNumber;
+  std::string Filename;
+};
+
+/// A representation of a parsed comment.
+struct CommentInfo {
+  std::string Kind;
+  std::string Text;
+  std::string Name;
+  std::string Direction;
+  std::string ParamName;
+  std::string CloseName;
+  bool SelfClosing = false;
+  bool Explicit = false;
+  llvm::SmallVector<NamedType, 4> Attrs;
+  llvm::SmallVector<std::string, 4> Args;
+  llvm::SmallVector<int, 4> Position;
+  std::vector<CommentInfo> Children;
+};
+
+/// A source file in the project.
+struct File {
+  std::string Filename;
+  CommentInfo Description;
+  llvm::SmallVector<CommentInfo, 8> UnattachedComments;
+};
+
+/// A base struct for Infos.
+struct Info {
+  bool isDefined = false;
+  std::string FullyQualifiedName;
+  std::string SimpleName;
+  std::string Namespace;
+  std::vector<CommentInfo> Descriptions;
+  llvm::SmallVector<Location, 2> Locations;
+};
+
+// TODO: Expand to allow for documenting templating.
+// Info for functions.
+struct FunctionInfo : public Info {
+  std::string MangledName;
+  std::string DefinitionFile;
+  std::string ReturnType;
+  llvm::SmallVector<NamedType, 4> Params;
+  AccessSpecifier Access;
+};
+
+struct NamespaceInfo : public Info {
+  llvm::StringMap<FunctionInfo> Functions;
+};
+
+// TODO: Expand to allow for documenting templating, inheritance access,
+// friend classes
+// Info for types.
+struct TypeInfo : public Info {
+  std::string DefinitionFile;
+  TagTypeKind TagType;
+  llvm::SmallVector<NamedType, 8> Members;
+  llvm::SmallVector<std::string, 8> Parents;
+  llvm::SmallVector<std::string, 8> VirtualParents;
+  llvm::StringMap<FunctionInfo> Functions;
+};
+
+// TODO: Expand to allow for documenting templating.
+// Info for types.
+struct EnumInfo : public Info {
+  std::string DefinitionFile;
+  bool Scoped;
+  llvm::SmallVector<NamedType, 8> Members;
+};
+
+/// A struct encapsulating all documentation information for the project.
+struct Documentation {
+  llvm::StringMap<File> Files;
+  llvm::StringMap<NamespaceInfo> Namespaces;
+  llvm::StringMap<TypeInfo> Types;
+  llvm::StringMap<EnumInfo> Enums;
+  // TODO: Add functionality to include separate markdown pages.
+};
+
+/// Struct with a key and a value to allow for serialization.
+template <typename T> struct Pair {
+  std::string Key;
+  T Value;
+};
+
+class ClangDocReporter : public ConstCommentVisitor<ClangDocReporter> {
+public:
+  ClangDocReporter() {}
+  ClangDocReporter(const std::vector<std::string> &Sources);
+
+  void addUnattachedComment(StringRef Filename, const CommentInfo &CI);
+  void addFile(StringRef Filename);
+
+  void createNamespaceInfo(const NamespaceDecl *D, const FullComment *C,
+                             int LineNumber, StringRef File);
+  void createTypeInfo(const RecordDecl *D, const FullComment *C, int LineNumber, StringRef File);
+  void createEnumInfo(const EnumDecl *D, const FullComment *C, int LineNumber, StringRef File);
+  void createFunctionInfo(const FunctionDecl *D, const FullComment *C,
+                        int LineNumber, StringRef File, StringRef MangledName);
+  void createMethodInfo(const CXXMethodDecl *D, const FullComment *C,
+                        int LineNumber, StringRef File, StringRef MangledName);
+                        
+  void parseFullComment(const FullComment *C, CommentInfo &CI);
+  void visitTextComment(const TextComment *C);
+  void visitInlineCommandComment(const InlineCommandComment *C);
+  void visitHTMLStartTagComment(const HTMLStartTagComment *C);
+  void visitHTMLEndTagComment(const HTMLEndTagComment *C);
+  void visitBlockCommandComment(const BlockCommandComment *C);
+  void visitParamCommandComment(const ParamCommandComment *C);
+  void visitTParamCommandComment(const TParamCommandComment *C);
+  void visitVerbatimBlockComment(const VerbatimBlockComment *C);
+  void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
+  void visitVerbatimLineComment(const VerbatimLineComment *C);
+
+  bool hasFile(StringRef Filename) const;
+  void serialize(clang::doc::OutFormat Format, llvm::raw_ostream &OS) const;
+
+private:
+  void addComment(Info &I, const FullComment *C);
+  void addLocation(Info &I, int LineNumber, StringRef File) const;
+  
+  void populateBasicInfo(Info &I, StringRef Name, StringRef SimpleName, StringRef Namespace);
+  void populateTypeInfo(TypeInfo &I, const RecordDecl *D, StringRef Name, StringRef File);
+  void populateEnumInfo(EnumInfo &I, const EnumDecl *D, StringRef Name, StringRef File);
+  void populateFunctionInfo(FunctionInfo &I, const FunctionDecl *D, StringRef Name, StringRef File, AccessSpecifier AS);
+
+  void parseComment(CommentInfo *CI, const comments::Comment *C);
+  void parseFields(TypeInfo &I, const RecordDecl *D) const;
+  void parseEnumerators(EnumInfo &I, const EnumDecl *D) const;
+  void parseBases(TypeInfo &I, const CXXRecordDecl *D) const;
+  void parseParameters(FunctionInfo &I, const FunctionDecl *D) const;
+
+  void serializeYAML(llvm::raw_ostream &OS) const;
+  void serializeLLVM(llvm::raw_ostream &OS) const;
+
+  const char *getCommandName(unsigned CommandID) const;
+  bool isWhitespaceOnly(StringRef S) const;
+  std::string getParentNamespace(const DeclContext *D) const;
+
+  CommentInfo *CurrentCI;
+  Documentation Docs;
+};
+
+} // namespace doc
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_REPORTER_H
Index: tools/clang-doc/ClangDocReporter.cpp
===================================================================
--- /dev/null
+++ tools/clang-doc/ClangDocReporter.cpp
@@ -0,0 +1,350 @@
+//===-- ClangDocReporter.cpp - ClangDoc Reporter ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangDocReporter.h"
+#include "ClangDocYAML.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+using clang::comments::FullComment;
+
+namespace clang {
+namespace doc {
+
+ClangDocReporter::ClangDocReporter(const std::vector<std::string> &Sources) {
+  for (const std::string &Path : Sources) {
+    assert(sys::path::is_absolute(Path) && "clang-doc expects absolute paths.");
+    addFile(Path);
+  }
+  // Create base namespace
+  NamespaceInfo I;
+  I.isDefined = true;
+  Docs.Namespaces[""] = I;
+}
+
+void ClangDocReporter::addUnattachedComment(StringRef Filename,
+                                            const CommentInfo &CI) {
+  Docs.Files[Filename].UnattachedComments.push_back(CI);
+}
+
+void ClangDocReporter::addFile(StringRef Filename) {
+  File F;
+  F.Filename = Filename;
+  Docs.Files.insert(std::make_pair(Filename, F));
+}
+
+void ClangDocReporter::createNamespaceInfo(const NamespaceDecl *D,
+                                             const FullComment *C,
+                                             int LineNumber, StringRef File) {
+  std::string Name = D->getQualifiedNameAsString();
+  llvm::StringMapIterator<NamespaceInfo> Pair = Docs.Namespaces.find(Name);
+  if (Pair == Docs.Namespaces.end()) {
+    NamespaceInfo I;
+    Docs.Namespaces[Name] = I;
+    populateBasicInfo(Docs.Namespaces[Name], Name, D->getNameAsString(), getParentNamespace(D));
+  }
+
+  addLocation(Docs.Namespaces[Name], LineNumber, File);
+  addComment(Docs.Namespaces[Name], C);
+}
+
+void ClangDocReporter::createTypeInfo(const RecordDecl *D, const FullComment *C,
+                                        int LineNumber, StringRef File) {
+
+  std::string Name = D->getQualifiedNameAsString();
+  llvm::StringMapIterator<TypeInfo> Pair = Docs.Types.find(Name);
+  if (Pair == Docs.Types.end()) {
+    TypeInfo I;
+    Docs.Types[Name] = I;
+  }
+    
+  if (D->isThisDeclarationADefinition()) 
+    populateTypeInfo(Docs.Types[Name], D, Name, File);
+  
+  addLocation(Docs.Types[Name], LineNumber, File);
+  addComment(Docs.Types[Name], C);
+}
+
+void ClangDocReporter::createEnumInfo(const EnumDecl *D, const FullComment *C,
+                                        int LineNumber, StringRef File) {
+  std::string Name = D->getQualifiedNameAsString();
+  llvm::StringMapIterator<EnumInfo> Pair = Docs.Enums.find(Name);
+  if (Pair == Docs.Enums.end()) {
+    EnumInfo I;
+    Docs.Enums[Name] = I;
+  }
+  
+  if (D->isThisDeclarationADefinition())
+    populateEnumInfo(Docs.Enums[Name], D, Name, File);
+
+  addLocation(Docs.Enums[Name], LineNumber, File);
+  addComment(Docs.Enums[Name], C);
+}
+
+void ClangDocReporter::createFunctionInfo(const FunctionDecl *D,
+                                            const FullComment *C, int LineNumber, StringRef File,
+                                            StringRef MangledName) {
+  std::string Namespace = getParentNamespace(D);
+  llvm::StringMapIterator<NamespaceInfo> NS = Docs.Namespaces.find(Namespace);
+  if (NS == Docs.Namespaces.end()) {
+    NamespaceInfo NI;;
+    NI.FullyQualifiedName = Namespace;
+    Docs.Namespaces[Namespace] = NI;
+  } 
+  
+  llvm::StringMapIterator<FunctionInfo> Pair = Docs.Namespaces[Namespace].Functions.find(MangledName);
+  if (Pair != Docs.Namespaces[Namespace].Functions.end()) {
+    FunctionInfo I;
+    Docs.Namespaces[Namespace].Functions[MangledName] = I;
+  }
+  
+  if (D->isThisDeclarationADefinition())
+    populateFunctionInfo(Docs.Namespaces[Namespace].Functions[MangledName], D, MangledName, File, clang::AccessSpecifier::AS_none);
+  
+  addLocation(Docs.Namespaces[Namespace].Functions[MangledName], LineNumber, File);
+  addComment(Docs.Namespaces[Namespace].Functions[MangledName], C);
+}
+
+void ClangDocReporter::createMethodInfo(const CXXMethodDecl *D,
+                                            const FullComment *C, int LineNumber, StringRef File,
+                                            StringRef MangledName) {
+  std::string ParentName = D->getParent()->getQualifiedNameAsString();
+  llvm::StringMapIterator<TypeInfo> T = Docs.Types.find(ParentName);
+  if (T == Docs.Types.end()) {
+    TypeInfo TI;
+    TI.FullyQualifiedName = getParentNamespace(D);
+    Docs.Types[ParentName] = TI;
+  } 
+  
+  llvm::StringMapIterator<FunctionInfo> Pair = Docs.Types[ParentName].Functions.find(MangledName);
+  if (Pair != Docs.Types[ParentName].Functions.end()) {
+    FunctionInfo I;
+    Docs.Types[ParentName].Functions[MangledName] = I;
+  }
+  
+  if (D->isThisDeclarationADefinition())
+    populateFunctionInfo(Docs.Types[ParentName].Functions[MangledName], D, MangledName, File, D->getAccess());
+  
+  addLocation(Docs.Types[ParentName].Functions[MangledName], LineNumber, File);
+  addComment(Docs.Types[ParentName].Functions[MangledName], C);
+}
+
+void ClangDocReporter::parseFullComment(const FullComment *C, CommentInfo &CI) {
+  parseComment(&CI, C);
+}
+
+void ClangDocReporter::visitTextComment(const TextComment *C) {
+  if (!isWhitespaceOnly(C->getText()))
+    CurrentCI->Text = C->getText();
+}
+
+void ClangDocReporter::visitInlineCommandComment(
+    const InlineCommandComment *C) {
+  CurrentCI->Name = getCommandName(C->getCommandID());
+  for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
+    CurrentCI->Args.push_back(C->getArgText(i));
+}
+
+void ClangDocReporter::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
+  CurrentCI->Name = C->getTagName();
+  CurrentCI->SelfClosing = C->isSelfClosing();
+  for (unsigned i = 0, e = C->getNumAttrs(); i < e; ++i) {
+    const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
+    NamedType T{Attr.Name, Attr.Value, clang::AccessSpecifier::AS_none};
+    CurrentCI->Attrs.push_back(T);
+  }
+}
+
+void ClangDocReporter::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
+  CurrentCI->Name = C->getTagName();
+  CurrentCI->SelfClosing = true;
+}
+
+void ClangDocReporter::visitBlockCommandComment(const BlockCommandComment *C) {
+  CurrentCI->Name = getCommandName(C->getCommandID());
+  for (unsigned i = 0, e = C->getNumArgs(); i < e; ++i)
+    CurrentCI->Args.push_back(C->getArgText(i));
+}
+
+void ClangDocReporter::visitParamCommandComment(const ParamCommandComment *C) {
+  CurrentCI->Direction =
+      ParamCommandComment::getDirectionAsString(C->getDirection());
+  CurrentCI->Explicit = C->isDirectionExplicit();
+  if (C->hasParamName() && C->isParamIndexValid())
+    CurrentCI->ParamName = C->getParamNameAsWritten();
+}
+
+void ClangDocReporter::visitTParamCommandComment(
+    const TParamCommandComment *C) {
+  if (C->hasParamName() && C->isPositionValid())
+    CurrentCI->ParamName = C->getParamNameAsWritten();
+
+  if (C->isPositionValid()) {
+    for (unsigned i = 0, e = C->getDepth(); i < e; ++i)
+      CurrentCI->Position.push_back(C->getIndex(i));
+  }
+}
+
+void ClangDocReporter::visitVerbatimBlockComment(
+    const VerbatimBlockComment *C) {
+  CurrentCI->Name = getCommandName(C->getCommandID());
+  CurrentCI->CloseName = C->getCloseName();
+}
+
+void ClangDocReporter::visitVerbatimBlockLineComment(
+    const VerbatimBlockLineComment *C) {
+  if (!isWhitespaceOnly(C->getText()))
+    CurrentCI->Text = C->getText();
+}
+
+void ClangDocReporter::visitVerbatimLineComment(const VerbatimLineComment *C) {
+  if (!isWhitespaceOnly(C->getText()))
+    CurrentCI->Text = C->getText();
+}
+
+bool ClangDocReporter::hasFile(StringRef Filename) const {
+  return Docs.Files.find(Filename) != Docs.Files.end();
+}
+
+void ClangDocReporter::serialize(OutFormat Format, raw_ostream &OS) const {
+  Format == clang::doc::OutFormat::LLVM ? serializeLLVM(OS) : serializeYAML(OS);
+}
+
+void ClangDocReporter::addComment(Info &I, const FullComment *C) {
+  if (!C)
+    return;
+  CommentInfo CI;
+  parseFullComment(C, CI);
+  I.Descriptions.push_back(CI);
+}
+
+void ClangDocReporter::addLocation(Info &I, int LineNumber, StringRef File) const {
+  Location L{LineNumber, File};
+  I.Locations.push_back(L);
+}
+
+void ClangDocReporter::populateBasicInfo(Info &I, StringRef Name, StringRef SimpleName, StringRef Namespace) {
+  I.FullyQualifiedName = Name;
+  I.SimpleName = SimpleName;
+  I.Namespace = Namespace;
+  I.isDefined = true;
+}
+
+void ClangDocReporter::populateTypeInfo(TypeInfo &I, const RecordDecl * D, StringRef Name, StringRef File) {
+  populateBasicInfo(I, Name, D->getNameAsString(), getParentNamespace(D));
+  I.TagType = D->getTagKind();
+  I.DefinitionFile = File;
+  if (const auto *CXXR = dyn_cast<CXXRecordDecl>(D))
+    parseBases(I, CXXR);
+  parseFields(I, D);
+}
+
+void ClangDocReporter::populateFunctionInfo(FunctionInfo &I, const FunctionDecl *D, StringRef Name, StringRef File, AccessSpecifier AS) {
+  populateBasicInfo(I, D->getQualifiedNameAsString(), D->getNameAsString(), getParentNamespace(D));
+  I.MangledName = Name;
+  I.DefinitionFile = File;
+  I.ReturnType = D->getReturnType().getAsString();
+  I.Access = AS;
+  parseParameters(I, D);
+}
+
+void ClangDocReporter::populateEnumInfo(EnumInfo &I, const EnumDecl *D, StringRef Name, StringRef File) {
+  populateBasicInfo(I, Name, D->getNameAsString(), getParentNamespace(D));
+  I.DefinitionFile = File;
+  I.Scoped = D->isScoped();
+  parseEnumerators(Docs.Enums[Name], D);
+}
+
+void ClangDocReporter::parseComment(CommentInfo *CI,
+                                    const comments::Comment *C) {
+  CurrentCI = CI;
+  CI->Kind = C->getCommentKindName();
+  ConstCommentVisitor<ClangDocReporter>::visit(C);
+  for (comments::Comment *Child :
+       make_range(C->child_begin(), C->child_end())) {
+    CommentInfo ChildCI;
+    parseComment(&ChildCI, Child);
+    CI->Children.push_back(ChildCI);
+  }
+}
+
+void ClangDocReporter::parseFields(TypeInfo &I, const RecordDecl *D) const {
+  for (const FieldDecl *F : D->fields()) {
+    NamedType N;
+    N.Type = F->getTypeSourceInfo()->getType().getAsString();
+    N.Name = F->getQualifiedNameAsString();
+    if (const auto *M = dyn_cast<CXXMethodDecl>(D))
+      N.Access = M->getAccess();
+    else 
+      N.Access = clang::AccessSpecifier::AS_none;
+    I.Members.push_back(N);
+  }
+}
+
+void ClangDocReporter::parseEnumerators(EnumInfo &I, const EnumDecl *D) const {
+  for (const EnumConstantDecl *E : D->enumerators()) {
+    NamedType N;
+    N.Type = E->getQualifiedNameAsString();
+    N.Access = clang::AccessSpecifier::AS_none;
+    I.Members.push_back(N);
+  }
+}
+
+void ClangDocReporter::parseParameters(FunctionInfo &I,
+                                       const FunctionDecl *D) const {
+  for (const ParmVarDecl *P : D->parameters()) {
+    NamedType Parm;
+    Parm.Type = P->getOriginalType().getAsString();
+    Parm.Access = clang::AccessSpecifier::AS_none;
+    Parm.Name = P->getQualifiedNameAsString();
+    I.Params.push_back(Parm);
+  }
+}
+
+void ClangDocReporter::parseBases(TypeInfo &I, const CXXRecordDecl *D) const {
+  for (const CXXBaseSpecifier &B : D->bases()) {
+    if (!B.isVirtual()) I.Parents.push_back(B.getType().getAsString());
+  }
+  for (const CXXBaseSpecifier &B : D->vbases())
+    I.VirtualParents.push_back(B.getType().getAsString());
+}
+
+void ClangDocReporter::serializeYAML(raw_ostream &OS) const {
+  yaml::Output Output(OS);
+  Documentation NonConstValue = Docs;
+  Output << NonConstValue;
+}
+
+void ClangDocReporter::serializeLLVM(raw_ostream &OS) const {
+  // TODO: Implement.
+  OS << "Not yet implemented.\n";
+}
+
+const char *ClangDocReporter::getCommandName(unsigned CommandID) const {
+  const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
+  if (Info)
+    return Info->Name;
+  // TODO: Add parsing for \file command.
+  return "<not a builtin command>";
+}
+
+bool ClangDocReporter::isWhitespaceOnly(StringRef S) const {
+  return S.find_first_not_of(" \t\n\v\f\r") == std::string::npos || S.empty();
+}
+
+std::string ClangDocReporter::getParentNamespace(const DeclContext *D) const {
+  if (const auto *N = dyn_cast<NamedDecl>(D->getParent()))
+    return N->getQualifiedNameAsString();
+  return "";
+}
+
+} // namespace doc
+} // namespace clang
Index: tools/clang-doc/ClangDocYAML.h
===================================================================
--- /dev/null
+++ tools/clang-doc/ClangDocYAML.h
@@ -0,0 +1,217 @@
+//===--  ClangDocYAML.h - ClangDoc YAML -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_YAML_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_YAML_H
+
+#include "llvm/Support/YAMLTraits.h"
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::CommentInfo)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::NamedType)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Location)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Pair<clang::doc::File>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Pair<clang::doc::NamespaceInfo>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Pair<clang::doc::TypeInfo>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Pair<clang::doc::EnumInfo>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::doc::Pair<clang::doc::FunctionInfo>)
+
+namespace llvm {
+namespace yaml {
+
+template <typename T> struct NormalizedMap {
+  NormalizedMap(IO &) {}
+  NormalizedMap(IO &, const StringMap<T> &Map) {
+    for (const auto &Entry : Map) {
+      clang::doc::Pair<T> Pair{Entry.getKeyData(), Entry.getValue()};
+      VectorMap.push_back(Pair);
+    }
+  }
+
+  StringMap<T> denormalize(IO &) {
+    StringMap<T> Map;
+    for (const auto &Pair : VectorMap)
+      Map[Pair.Key] = Pair.Value;
+    return Map;
+  }
+
+  std::vector<clang::doc::Pair<T>> VectorMap;
+};
+
+template <> struct ScalarEnumerationTraits<clang::AccessSpecifier> {
+  static void enumeration(IO &io, clang::AccessSpecifier &value) {
+    io.enumCase(value, "Public", clang::AccessSpecifier::AS_public);
+    io.enumCase(value, "Protected", clang::AccessSpecifier::AS_protected);
+    io.enumCase(value, "Private", clang::AccessSpecifier::AS_private);
+    io.enumCase(value, "None", clang::AccessSpecifier::AS_none);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<clang::TagTypeKind> {
+  static void enumeration(IO &io, clang::TagTypeKind &value) {
+    io.enumCase(value, "Struct", clang::TagTypeKind::TTK_Struct);
+    io.enumCase(value, "Interface", clang::TagTypeKind::TTK_Interface);
+    io.enumCase(value, "Union", clang::TagTypeKind::TTK_Union);
+    io.enumCase(value, "Class", clang::TagTypeKind::TTK_Class);
+    io.enumCase(value, "Enum", clang::TagTypeKind::TTK_Enum);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Pair<std::string>> {
+  static void mapping(IO &IO, clang::doc::Pair<std::string> &Pair) {
+    IO.mapOptional("Value", Pair.Value);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Location> {
+  static void mapping(IO &IO, clang::doc::Location &Location) {
+    IO.mapOptional("LineNumber", Location.LineNumber);
+    IO.mapOptional("Filename", Location.Filename);
+  }
+};
+
+// TODO: uncomment description attrs
+template <> struct MappingTraits<clang::doc::Pair<clang::doc::NamespaceInfo>> {
+  static void mapping(IO &IO, clang::doc::Pair<clang::doc::NamespaceInfo> &Pair) {
+    if (!Pair.Value.isDefined)
+      return;
+  MappingNormalization<NormalizedMap<clang::doc::FunctionInfo>,
+                         StringMap<clang::doc::FunctionInfo>>
+        functions(IO, Pair.Value.Functions);
+
+    IO.mapOptional("Qualified Name", Pair.Value.FullyQualifiedName);
+    IO.mapOptional("Name", Pair.Value.SimpleName);
+    IO.mapOptional("Namespace", Pair.Value.Namespace);
+    IO.mapOptional("Descriptions", Pair.Value.Descriptions);
+    IO.mapOptional("Locations", Pair.Value.Locations);
+    IO.mapOptional("Functions", functions->VectorMap);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Pair<clang::doc::TypeInfo>> {
+  static void mapping(IO &IO, clang::doc::Pair<clang::doc::TypeInfo> &Pair) {
+    if (!Pair.Value.isDefined)
+      return;
+
+    MappingNormalization<NormalizedMap<clang::doc::FunctionInfo>,
+                         StringMap<clang::doc::FunctionInfo>>
+        functions(IO, Pair.Value.Functions);
+        
+    IO.mapOptional("Qualified Name", Pair.Value.FullyQualifiedName);
+    IO.mapOptional("Name", Pair.Value.SimpleName);
+    IO.mapOptional("Namespace", Pair.Value.Namespace);
+    IO.mapOptional("Descriptions", Pair.Value.Descriptions);
+    IO.mapOptional("TagType", Pair.Value.TagType);
+    IO.mapOptional("Locations", Pair.Value.Locations);
+    IO.mapOptional("Functions", functions->VectorMap);
+    IO.mapOptional("DefinitionFile", Pair.Value.DefinitionFile);
+    IO.mapOptional("Members", Pair.Value.Members);
+    IO.mapOptional("Parents", Pair.Value.Parents);
+    IO.mapOptional("VirtualParents", Pair.Value.VirtualParents);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Pair<clang::doc::EnumInfo>> {
+  static void mapping(IO &IO, clang::doc::Pair<clang::doc::EnumInfo> &Pair) {
+    if (!Pair.Value.isDefined)
+      return;
+    IO.mapOptional("Qualified Name", Pair.Value.FullyQualifiedName);
+    IO.mapOptional("Name", Pair.Value.SimpleName);
+    IO.mapOptional("Namespace", Pair.Value.Namespace);
+    IO.mapOptional("Descriptions", Pair.Value.Descriptions);
+    IO.mapOptional("Locations", Pair.Value.Locations);
+    IO.mapOptional("DefinitionFile", Pair.Value.DefinitionFile);
+    IO.mapOptional("Scoped", Pair.Value.Scoped);
+    IO.mapOptional("Members", Pair.Value.Members);  
+  }
+};
+
+template <> struct MappingTraits<clang::doc::NamedType> {
+  static void mapping(IO &IO, clang::doc::NamedType &NamedType) {
+    IO.mapOptional("Type", NamedType.Type);
+    IO.mapOptional("Name", NamedType.Name);
+    IO.mapOptional("Access", NamedType.Access);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Pair<clang::doc::FunctionInfo>> {
+  static void mapping(IO &IO,
+                      clang::doc::Pair<clang::doc::FunctionInfo> &Pair) {
+    if (!Pair.Value.isDefined)
+      return;
+    IO.mapOptional("Mangled Name", Pair.Value.MangledName);
+    IO.mapOptional("Qualified Name", Pair.Value.FullyQualifiedName);
+    IO.mapOptional("Name", Pair.Value.SimpleName);
+    IO.mapOptional("Namespace", Pair.Value.Namespace);
+    IO.mapOptional("Descriptions", Pair.Value.Descriptions);
+    IO.mapOptional("Locations", Pair.Value.Locations);
+    IO.mapOptional("DefinitionFile", Pair.Value.DefinitionFile);
+    IO.mapOptional("Params", Pair.Value.Params);
+    IO.mapOptional("ReturnType", Pair.Value.ReturnType);
+    IO.mapOptional("Access", Pair.Value.Access);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Pair<clang::doc::File>> {
+  static void mapping(IO &IO, clang::doc::Pair<clang::doc::File> &Pair) {
+    IO.mapOptional("Filename", Pair.Value.Filename);
+    IO.mapOptional("Description", Pair.Value.Description);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::Documentation> {
+  static void mapping(IO &IO, clang::doc::Documentation &Docs) {
+    MappingNormalization<NormalizedMap<clang::doc::File>,
+                         StringMap<clang::doc::File>>
+        files(IO, Docs.Files);
+    MappingNormalization<NormalizedMap<clang::doc::NamespaceInfo>,
+                         StringMap<clang::doc::NamespaceInfo>>
+        namespaces(IO, Docs.Namespaces);
+    MappingNormalization<NormalizedMap<clang::doc::TypeInfo>,
+                          StringMap<clang::doc::TypeInfo>>
+        types(IO, Docs.Types);
+    MappingNormalization<NormalizedMap<clang::doc::EnumInfo>,
+                            StringMap<clang::doc::EnumInfo>>
+        enums(IO, Docs.Enums);
+
+    IO.mapOptional("Files", files->VectorMap);
+    IO.mapOptional("Namespaces", namespaces->VectorMap);
+    IO.mapOptional("Types", types->VectorMap);
+    IO.mapOptional("Enums", enums->VectorMap);
+  }
+};
+
+template <> struct MappingTraits<clang::doc::CommentInfo> {
+
+  static void mapping(IO &IO, clang::doc::CommentInfo &Info) {
+    IO.mapOptional("Kind", Info.Kind);
+    if (!Info.Text.empty())
+      IO.mapOptional("Text", Info.Text);
+    if (!Info.Name.empty())
+      IO.mapOptional("Name", Info.Name);
+    if (!Info.Direction.empty())
+      IO.mapOptional("Direction", Info.Direction);
+    if (!Info.ParamName.empty())
+      IO.mapOptional("ParamName", Info.ParamName);
+    if (!Info.CloseName.empty())
+      IO.mapOptional("CloseName", Info.CloseName);
+    if (Info.SelfClosing)
+      IO.mapOptional("SelfClosing", Info.SelfClosing);
+    if (Info.Explicit)
+      IO.mapOptional("Explicit", Info.Explicit);
+    IO.mapOptional("Args", Info.Args);
+    IO.mapOptional("Attrs", Info.Attrs);
+    IO.mapOptional("Position", Info.Position);
+    IO.mapOptional("Children", Info.Children);
+  }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANG_DOC_YAML_H
Index: tools/clang-doc/tool/CMakeLists.txt
===================================================================
--- /dev/null
+++ tools/clang-doc/tool/CMakeLists.txt
@@ -0,0 +1,18 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+add_clang_executable(clang-doc
+  ClangDocMain.cpp
+  )
+
+target_link_libraries(clang-doc
+  PRIVATE
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangFormat
+  clangFrontend
+  clangDoc
+  clangRewrite
+  clangTooling
+  clangToolingCore
+  )
Index: tools/clang-doc/tool/ClangDocMain.cpp
===================================================================
--- /dev/null
+++ tools/clang-doc/tool/ClangDocMain.cpp
@@ -0,0 +1,68 @@
+//===-- ClangDocMain.cpp - Clangdoc -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangDoc.h"
+#include "clang/Driver/Options.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Signals.h"
+#include <string>
+
+using namespace clang;
+using namespace llvm;
+
+namespace {
+
+cl::OptionCategory ClangDocCategory("clang-doc options");
+
+cl::opt<bool>
+    EmitLLVM("emit-llvm",
+             cl::desc("Output in LLVM bitstream format (default is YAML)."),
+             cl::init(false), cl::cat(ClangDocCategory));
+
+cl::opt<bool>
+    DoxygenOnly("doxygen",
+                cl::desc("Use only doxygen-style comments to generate docs."),
+                cl::init(false), cl::cat(ClangDocCategory));
+
+} // namespace
+
+int main(int argc, const char **argv) {
+  sys::PrintStackTraceOnErrorSignal(argv[0]);
+  tooling::CommonOptionsParser OptionsParser(argc, argv, ClangDocCategory);
+
+  clang::doc::OutFormat EmitFormat =
+      EmitLLVM ? doc::OutFormat::LLVM : doc::OutFormat::YAML;
+
+  // TODO: Update the source path list to only consider changed files for
+  // incremental doc updates.
+  doc::ClangDocReporter Reporter(OptionsParser.getSourcePathList());
+  doc::ClangDocContext Context{EmitFormat};
+
+  tooling::ClangTool Tool(OptionsParser.getCompilations(),
+                          OptionsParser.getSourcePathList());
+
+  if (!DoxygenOnly)
+    Tool.appendArgumentsAdjuster(tooling::getInsertArgumentAdjuster(
+        "-fparse-all-comments", tooling::ArgumentInsertPosition::BEGIN));
+
+  doc::ClangDocActionFactory Factory(Context, Reporter);
+
+  outs() << "Parsing codebase...\n";
+  int Status = Tool.run(&Factory);
+  if (Status)
+    return Status;
+
+  outs() << "Writing docs...\n";
+  Reporter.serialize(EmitFormat, outs());
+
+  return 0;
+}