clang-tools-extra/clang-doc/BitcodeWriter.cpp

   1 //===--  BitcodeWriter.cpp - ClangDoc Bitcode Writer ------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "BitcodeWriter.h"
  10 #include "llvm/ADT/IndexedMap.h"
  11 #include <initializer_list>
  12
  13 namespace clang {
  14 namespace doc {
  15
  16 // Empty SymbolID for comparison, so we don't have to construct one every time.
  17 static const SymbolID EmptySID = SymbolID();
  18
  19 // Since id enums are not zero-indexed, we need to transform the given id into
  20 // its associated index.
  21 struct BlockIdToIndexFunctor {
  22   using argument_type = unsigned;
  23   unsigned operator()(unsigned ID) const { return ID - BI_FIRST; }
  24 };
  25
  26 struct RecordIdToIndexFunctor {
  27   using argument_type = unsigned;
  28   unsigned operator()(unsigned ID) const { return ID - RI_FIRST; }
  29 };
  30
  31 using AbbrevDsc = void (*)(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev);
  32
  33 static void AbbrevGen(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev,
  34                       const std::initializer_list<llvm::BitCodeAbbrevOp> Ops) {
  35   for (const auto &Op : Ops)
  36     Abbrev->Add(Op);
  37 }
  38
  39 static void BoolAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
  40   AbbrevGen(Abbrev,
  41             {// 0. Boolean
  42              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  43                                    BitCodeConstants::BoolSize)});
  44 }
  45
  46 static void IntAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
  47   AbbrevGen(Abbrev,
  48             {// 0. Fixed-size integer
  49              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  50                                    BitCodeConstants::IntSize)});
  51 }
  52
  53 static void SymbolIDAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
  54   AbbrevGen(Abbrev,
  55             {// 0. Fixed-size integer (length of the sha1'd USR)
  56              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  57                                    BitCodeConstants::USRLengthSize),
  58              // 1. Fixed-size array of Char6 (USR)
  59              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array),
  60              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  61                                    BitCodeConstants::USRBitLengthSize)});
  62 }
  63
  64 static void StringAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
  65   AbbrevGen(Abbrev,
  66             {// 0. Fixed-size integer (length of the following string)
  67              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  68                                    BitCodeConstants::StringLengthSize),
  69              // 1. The string blob
  70              llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
  71 }
  72
  73 // Assumes that the file will not have more than 65535 lines.
  74 static void LocationAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
  75   AbbrevGen(
  76       Abbrev,
  77       {// 0. Fixed-size integer (line number)
  78        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  79                              BitCodeConstants::LineNumberSize),
  80        // 1. Boolean (IsFileInRootDir)
  81        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  82                              BitCodeConstants::BoolSize),
  83        // 2. Fixed-size integer (length of the following string (filename))
  84        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
  85                              BitCodeConstants::StringLengthSize),
  86        // 3. The string blob
  87        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
  88 }
  89
  90 struct RecordIdDsc {
  91   llvm::StringRef Name;
  92   AbbrevDsc Abbrev = nullptr;
  93
  94   RecordIdDsc() = default;
  95   RecordIdDsc(llvm::StringRef Name, AbbrevDsc Abbrev)
  96       : Name(Name), Abbrev(Abbrev) {}
  97
  98   // Is this 'description' valid?
  99   operator bool() const {
 100     return Abbrev != nullptr && Name.data() != nullptr && !Name.empty();
 101   }
 102 };
 103
 104 static const llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor>
 105     BlockIdNameMap = []() {
 106       llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor> BlockIdNameMap;
 107       BlockIdNameMap.resize(BlockIdCount);
 108
 109       // There is no init-list constructor for the IndexedMap, so have to
 110       // improvise
 111       static const std::vector<std::pair<BlockId, const char *const>> Inits = {
 112           {BI_VERSION_BLOCK_ID, "VersionBlock"},
 113           {BI_NAMESPACE_BLOCK_ID, "NamespaceBlock"},
 114           {BI_ENUM_BLOCK_ID, "EnumBlock"},
 115           {BI_TYPE_BLOCK_ID, "TypeBlock"},
 116           {BI_FIELD_TYPE_BLOCK_ID, "FieldTypeBlock"},
 117           {BI_MEMBER_TYPE_BLOCK_ID, "MemberTypeBlock"},
 118           {BI_RECORD_BLOCK_ID, "RecordBlock"},
 119           {BI_BASE_RECORD_BLOCK_ID, "BaseRecordBlock"},
 120           {BI_FUNCTION_BLOCK_ID, "FunctionBlock"},
 121           {BI_COMMENT_BLOCK_ID, "CommentBlock"},
 122           {BI_REFERENCE_BLOCK_ID, "ReferenceBlock"}};
 123       assert(Inits.size() == BlockIdCount);
 124       for (const auto &Init : Inits)
 125         BlockIdNameMap[Init.first] = Init.second;
 126       assert(BlockIdNameMap.size() == BlockIdCount);
 127       return BlockIdNameMap;
 128     }();
 129
 130 static const llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor>
 131     RecordIdNameMap = []() {
 132       llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor> RecordIdNameMap;
 133       RecordIdNameMap.resize(RecordIdCount);
 134
 135       // There is no init-list constructor for the IndexedMap, so have to
 136       // improvise
 137       static const std::vector<std::pair<RecordId, RecordIdDsc>> Inits = {
 138           {VERSION, {"Version", &IntAbbrev}},
 139           {COMMENT_KIND, {"Kind", &StringAbbrev}},
 140           {COMMENT_TEXT, {"Text", &StringAbbrev}},
 141           {COMMENT_NAME, {"Name", &StringAbbrev}},
 142           {COMMENT_DIRECTION, {"Direction", &StringAbbrev}},
 143           {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}},
 144           {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}},
 145           {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}},
 146           {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}},
 147           {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}},
 148           {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}},
 149           {COMMENT_ARG, {"Arg", &StringAbbrev}},
 150           {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
 151           {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
 152           {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}},
 153           {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}},
 154           {NAMESPACE_NAME, {"Name", &StringAbbrev}},
 155           {NAMESPACE_PATH, {"Path", &StringAbbrev}},
 156           {ENUM_USR, {"USR", &SymbolIDAbbrev}},
 157           {ENUM_NAME, {"Name", &StringAbbrev}},
 158           {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
 159           {ENUM_LOCATION, {"Location", &LocationAbbrev}},
 160           {ENUM_MEMBER, {"Member", &StringAbbrev}},
 161           {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
 162           {RECORD_USR, {"USR", &SymbolIDAbbrev}},
 163           {RECORD_NAME, {"Name", &StringAbbrev}},
 164           {RECORD_PATH, {"Path", &StringAbbrev}},
 165           {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
 166           {RECORD_LOCATION, {"Location", &LocationAbbrev}},
 167           {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
 168           {RECORD_IS_TYPE_DEF, {"IsTypeDef", &BoolAbbrev}},
 169           {BASE_RECORD_USR, {"USR", &SymbolIDAbbrev}},
 170           {BASE_RECORD_NAME, {"Name", &StringAbbrev}},
 171           {BASE_RECORD_PATH, {"Path", &StringAbbrev}},
 172           {BASE_RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
 173           {BASE_RECORD_IS_VIRTUAL, {"IsVirtual", &BoolAbbrev}},
 174           {BASE_RECORD_ACCESS, {"Access", &IntAbbrev}},
 175           {BASE_RECORD_IS_PARENT, {"IsParent", &BoolAbbrev}},
 176           {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
 177           {FUNCTION_NAME, {"Name", &StringAbbrev}},
 178           {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
 179           {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
 180           {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
 181           {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
 182           {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
 183           {REFERENCE_NAME, {"Name", &StringAbbrev}},
 184           {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
 185           {REFERENCE_PATH, {"Path", &StringAbbrev}},
 186           {REFERENCE_IS_IN_GLOBAL_NAMESPACE,
 187            {"IsInGlobalNamespace", &BoolAbbrev}},
 188           {REFERENCE_FIELD, {"Field", &IntAbbrev}}};
 189       assert(Inits.size() == RecordIdCount);
 190       for (const auto &Init : Inits) {
 191         RecordIdNameMap[Init.first] = Init.second;
 192         assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize);
 193       }
 194       assert(RecordIdNameMap.size() == RecordIdCount);
 195       return RecordIdNameMap;
 196     }();
 197
 198 static const std::vector<std::pair<BlockId, std::vector<RecordId>>>
 199     RecordsByBlock{
 200         // Version Block
 201         {BI_VERSION_BLOCK_ID, {VERSION}},
 202         // Comment Block
 203         {BI_COMMENT_BLOCK_ID,
 204          {COMMENT_KIND, COMMENT_TEXT, COMMENT_NAME, COMMENT_DIRECTION,
 205           COMMENT_PARAMNAME, COMMENT_CLOSENAME, COMMENT_SELFCLOSING,
 206           COMMENT_EXPLICIT, COMMENT_ATTRKEY, COMMENT_ATTRVAL, COMMENT_ARG}},
 207         // Type Block
 208         {BI_TYPE_BLOCK_ID, {}},
 209         // FieldType Block
 210         {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME}},
 211         // MemberType Block
 212         {BI_MEMBER_TYPE_BLOCK_ID, {MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}},
 213         // Enum Block
 214         {BI_ENUM_BLOCK_ID,
 215          {ENUM_USR, ENUM_NAME, ENUM_DEFLOCATION, ENUM_LOCATION, ENUM_MEMBER,
 216           ENUM_SCOPED}},
 217         // Namespace Block
 218         {BI_NAMESPACE_BLOCK_ID,
 219          {NAMESPACE_USR, NAMESPACE_NAME, NAMESPACE_PATH}},
 220         // Record Block
 221         {BI_RECORD_BLOCK_ID,
 222          {RECORD_USR, RECORD_NAME, RECORD_PATH, RECORD_DEFLOCATION,
 223           RECORD_LOCATION, RECORD_TAG_TYPE, RECORD_IS_TYPE_DEF}},
 224         // BaseRecord Block
 225         {BI_BASE_RECORD_BLOCK_ID,
 226          {BASE_RECORD_USR, BASE_RECORD_NAME, BASE_RECORD_PATH,
 227           BASE_RECORD_TAG_TYPE, BASE_RECORD_IS_VIRTUAL, BASE_RECORD_ACCESS,
 228           BASE_RECORD_IS_PARENT}},
 229         // Function Block
 230         {BI_FUNCTION_BLOCK_ID,
 231          {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION,
 232           FUNCTION_ACCESS, FUNCTION_IS_METHOD}},
 233         // Reference Block
 234         {BI_REFERENCE_BLOCK_ID,
 235          {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_PATH,
 236           REFERENCE_IS_IN_GLOBAL_NAMESPACE, REFERENCE_FIELD}}};
 237
 238 // AbbreviationMap
 239
 240 constexpr unsigned char BitCodeConstants::Signature[];
 241
 242 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
 243                                                  unsigned AbbrevID) {
 244   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
 245   assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added.");
 246   Abbrevs[RID] = AbbrevID;
 247 }
 248
 249 unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const {
 250   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
 251   assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation.");
 252   return Abbrevs.lookup(RID);
 253 }
 254
 255 // Validation and Overview Blocks
 256
 257 /// Emits the magic number header to check that its the right format,
 258 /// in this case, 'DOCS'.
 259 void ClangDocBitcodeWriter::emitHeader() {
 260   for (char C : BitCodeConstants::Signature)
 261     Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize);
 262 }
 263
 264 void ClangDocBitcodeWriter::emitVersionBlock() {
 265   StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID);
 266   emitRecord(VersionNumber, VERSION);
 267 }
 268
 269 /// Emits a block ID and the block name to the BLOCKINFO block.
 270 void ClangDocBitcodeWriter::emitBlockID(BlockId BID) {
 271   const auto &BlockIdName = BlockIdNameMap[BID];
 272   assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId.");
 273
 274   Record.clear();
 275   Record.push_back(BID);
 276   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
 277   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
 278                     ArrayRef<unsigned char>(BlockIdName.bytes_begin(),
 279                                             BlockIdName.bytes_end()));
 280 }
 281
 282 /// Emits a record name to the BLOCKINFO block.
 283 void ClangDocBitcodeWriter::emitRecordID(RecordId ID) {
 284   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 285   prepRecordData(ID);
 286   Record.append(RecordIdNameMap[ID].Name.begin(),
 287                 RecordIdNameMap[ID].Name.end());
 288   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
 289 }
 290
 291 // Abbreviations
 292
 293 void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId Block) {
 294   assert(RecordIdNameMap[ID] && "Unknown abbreviation.");
 295   auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>();
 296   Abbrev->Add(llvm::BitCodeAbbrevOp(ID));
 297   RecordIdNameMap[ID].Abbrev(Abbrev);
 298   Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev)));
 299 }
 300
 301 // Records
 302
 303 void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) {
 304   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 305   assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev &&
 306          "Abbrev type mismatch.");
 307   if (!prepRecordData(ID, Sym != EmptySID))
 308     return;
 309   assert(Sym.size() == 20);
 310   Record.push_back(Sym.size());
 311   Record.append(Sym.begin(), Sym.end());
 312   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 313 }
 314
 315 void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) {
 316   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 317   assert(RecordIdNameMap[ID].Abbrev == &StringAbbrev &&
 318          "Abbrev type mismatch.");
 319   if (!prepRecordData(ID, !Str.empty()))
 320     return;
 321   assert(Str.size() < (1U << BitCodeConstants::StringLengthSize));
 322   Record.push_back(Str.size());
 323   Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Str);
 324 }
 325
 326 void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) {
 327   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 328   assert(RecordIdNameMap[ID].Abbrev == &LocationAbbrev &&
 329          "Abbrev type mismatch.");
 330   if (!prepRecordData(ID, true))
 331     return;
 332   // FIXME: Assert that the line number is of the appropriate size.
 333   Record.push_back(Loc.LineNumber);
 334   assert(Loc.Filename.size() < (1U << BitCodeConstants::StringLengthSize));
 335   Record.push_back(Loc.IsFileInRootDir);
 336   Record.push_back(Loc.Filename.size());
 337   Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Loc.Filename);
 338 }
 339
 340 void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) {
 341   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 342   assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch.");
 343   if (!prepRecordData(ID, Val))
 344     return;
 345   Record.push_back(Val);
 346   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 347 }
 348
 349 void ClangDocBitcodeWriter::emitRecord(int Val, RecordId ID) {
 350   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 351   assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
 352   if (!prepRecordData(ID, Val))
 353     return;
 354   // FIXME: Assert that the integer is of the appropriate size.
 355   Record.push_back(Val);
 356   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 357 }
 358
 359 void ClangDocBitcodeWriter::emitRecord(unsigned Val, RecordId ID) {
 360   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 361   assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
 362   if (!prepRecordData(ID, Val))
 363     return;
 364   assert(Val < (1U << BitCodeConstants::IntSize));
 365   Record.push_back(Val);
 366   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 367 }
 368
 369 bool ClangDocBitcodeWriter::prepRecordData(RecordId ID, bool ShouldEmit) {
 370   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
 371   if (!ShouldEmit)
 372     return false;
 373   Record.clear();
 374   Record.push_back(ID);
 375   return true;
 376 }
 377
 378 // BlockInfo Block
 379
 380 void ClangDocBitcodeWriter::emitBlockInfoBlock() {
 381   Stream.EnterBlockInfoBlock();
 382   for (const auto &Block : RecordsByBlock) {
 383     assert(Block.second.size() < (1U << BitCodeConstants::SubblockIDSize));
 384     emitBlockInfo(Block.first, Block.second);
 385   }
 386   Stream.ExitBlock();
 387 }
 388
 389 void ClangDocBitcodeWriter::emitBlockInfo(BlockId BID,
 390                                           const std::vector<RecordId> &RIDs) {
 391   assert(RIDs.size() < (1U << BitCodeConstants::SubblockIDSize));
 392   emitBlockID(BID);
 393   for (RecordId RID : RIDs) {
 394     emitRecordID(RID);
 395     emitAbbrev(RID, BID);
 396   }
 397 }
 398
 399 // Block emission
 400
 401 void ClangDocBitcodeWriter::emitBlock(const Reference &R, FieldId Field) {
 402   if (R.USR == EmptySID && R.Name.empty())
 403     return;
 404   StreamSubBlockGuard Block(Stream, BI_REFERENCE_BLOCK_ID);
 405   emitRecord(R.USR, REFERENCE_USR);
 406   emitRecord(R.Name, REFERENCE_NAME);
 407   emitRecord((unsigned)R.RefType, REFERENCE_TYPE);
 408   emitRecord(R.Path, REFERENCE_PATH);
 409   emitRecord(R.IsInGlobalNamespace, REFERENCE_IS_IN_GLOBAL_NAMESPACE);
 410   emitRecord((unsigned)Field, REFERENCE_FIELD);
 411 }
 412
 413 void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) {
 414   StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID);
 415   emitBlock(T.Type, FieldId::F_type);
 416 }
 417
 418 void ClangDocBitcodeWriter::emitBlock(const FieldTypeInfo &T) {
 419   StreamSubBlockGuard Block(Stream, BI_FIELD_TYPE_BLOCK_ID);
 420   emitBlock(T.Type, FieldId::F_type);
 421   emitRecord(T.Name, FIELD_TYPE_NAME);
 422 }
 423
 424 void ClangDocBitcodeWriter::emitBlock(const MemberTypeInfo &T) {
 425   StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID);
 426   emitBlock(T.Type, FieldId::F_type);
 427   emitRecord(T.Name, MEMBER_TYPE_NAME);
 428   emitRecord(T.Access, MEMBER_TYPE_ACCESS);
 429 }
 430
 431 void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) {
 432   StreamSubBlockGuard Block(Stream, BI_COMMENT_BLOCK_ID);
 433   for (const auto &L : std::vector<std::pair<llvm::StringRef, RecordId>>{
 434            {I.Kind, COMMENT_KIND},
 435            {I.Text, COMMENT_TEXT},
 436            {I.Name, COMMENT_NAME},
 437            {I.Direction, COMMENT_DIRECTION},
 438            {I.ParamName, COMMENT_PARAMNAME},
 439            {I.CloseName, COMMENT_CLOSENAME}})
 440     emitRecord(L.first, L.second);
 441   emitRecord(I.SelfClosing, COMMENT_SELFCLOSING);
 442   emitRecord(I.Explicit, COMMENT_EXPLICIT);
 443   for (const auto &A : I.AttrKeys)
 444     emitRecord(A, COMMENT_ATTRKEY);
 445   for (const auto &A : I.AttrValues)
 446     emitRecord(A, COMMENT_ATTRVAL);
 447   for (const auto &A : I.Args)
 448     emitRecord(A, COMMENT_ARG);
 449   for (const auto &C : I.Children)
 450     emitBlock(*C);
 451 }
 452
 453 void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) {
 454   StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID);
 455   emitRecord(I.USR, NAMESPACE_USR);
 456   emitRecord(I.Name, NAMESPACE_NAME);
 457   emitRecord(I.Path, NAMESPACE_PATH);
 458   for (const auto &N : I.Namespace)
 459     emitBlock(N, FieldId::F_namespace);
 460   for (const auto &CI : I.Description)
 461     emitBlock(CI);
 462   for (const auto &C : I.ChildNamespaces)
 463     emitBlock(C, FieldId::F_child_namespace);
 464   for (const auto &C : I.ChildRecords)
 465     emitBlock(C, FieldId::F_child_record);
 466   for (const auto &C : I.ChildFunctions)
 467     emitBlock(C);
 468   for (const auto &C : I.ChildEnums)
 469     emitBlock(C);
 470 }
 471
 472 void ClangDocBitcodeWriter::emitBlock(const EnumInfo &I) {
 473   StreamSubBlockGuard Block(Stream, BI_ENUM_BLOCK_ID);
 474   emitRecord(I.USR, ENUM_USR);
 475   emitRecord(I.Name, ENUM_NAME);
 476   for (const auto &N : I.Namespace)
 477     emitBlock(N, FieldId::F_namespace);
 478   for (const auto &CI : I.Description)
 479     emitBlock(CI);
 480   if (I.DefLoc)
 481     emitRecord(I.DefLoc.getValue(), ENUM_DEFLOCATION);
 482   for (const auto &L : I.Loc)
 483     emitRecord(L, ENUM_LOCATION);
 484   emitRecord(I.Scoped, ENUM_SCOPED);
 485   for (const auto &N : I.Members)
 486     emitRecord(N, ENUM_MEMBER);
 487 }
 488
 489 void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
 490   StreamSubBlockGuard Block(Stream, BI_RECORD_BLOCK_ID);
 491   emitRecord(I.USR, RECORD_USR);
 492   emitRecord(I.Name, RECORD_NAME);
 493   emitRecord(I.Path, RECORD_PATH);
 494   for (const auto &N : I.Namespace)
 495     emitBlock(N, FieldId::F_namespace);
 496   for (const auto &CI : I.Description)
 497     emitBlock(CI);
 498   if (I.DefLoc)
 499     emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION);
 500   for (const auto &L : I.Loc)
 501     emitRecord(L, RECORD_LOCATION);
 502   emitRecord(I.TagType, RECORD_TAG_TYPE);
 503   emitRecord(I.IsTypeDef, RECORD_IS_TYPE_DEF);
 504   for (const auto &N : I.Members)
 505     emitBlock(N);
 506   for (const auto &P : I.Parents)
 507     emitBlock(P, FieldId::F_parent);
 508   for (const auto &P : I.VirtualParents)
 509     emitBlock(P, FieldId::F_vparent);
 510   for (const auto &PB : I.Bases)
 511     emitBlock(PB);
 512   for (const auto &C : I.ChildRecords)
 513     emitBlock(C, FieldId::F_child_record);
 514   for (const auto &C : I.ChildFunctions)
 515     emitBlock(C);
 516   for (const auto &C : I.ChildEnums)
 517     emitBlock(C);
 518 }
 519
 520 void ClangDocBitcodeWriter::emitBlock(const BaseRecordInfo &I) {
 521   StreamSubBlockGuard Block(Stream, BI_BASE_RECORD_BLOCK_ID);
 522   emitRecord(I.USR, BASE_RECORD_USR);
 523   emitRecord(I.Name, BASE_RECORD_NAME);
 524   emitRecord(I.Path, BASE_RECORD_PATH);
 525   emitRecord(I.TagType, BASE_RECORD_TAG_TYPE);
 526   emitRecord(I.IsVirtual, BASE_RECORD_IS_VIRTUAL);
 527   emitRecord(I.Access, BASE_RECORD_ACCESS);
 528   emitRecord(I.IsParent, BASE_RECORD_IS_PARENT);
 529   for (const auto &M : I.Members)
 530     emitBlock(M);
 531   for (const auto &C : I.ChildFunctions)
 532     emitBlock(C);
 533 }
 534
 535 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
 536   StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
 537   emitRecord(I.USR, FUNCTION_USR);
 538   emitRecord(I.Name, FUNCTION_NAME);
 539   for (const auto &N : I.Namespace)
 540     emitBlock(N, FieldId::F_namespace);
 541   for (const auto &CI : I.Description)
 542     emitBlock(CI);
 543   emitRecord(I.Access, FUNCTION_ACCESS);
 544   emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
 545   if (I.DefLoc)
 546     emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION);
 547   for (const auto &L : I.Loc)
 548     emitRecord(L, FUNCTION_LOCATION);
 549   emitBlock(I.Parent, FieldId::F_parent);
 550   emitBlock(I.ReturnType);
 551   for (const auto &N : I.Params)
 552     emitBlock(N);
 553 }
 554
 555 bool ClangDocBitcodeWriter::dispatchInfoForWrite(Info *I) {
 556   switch (I->IT) {
 557   case InfoType::IT_namespace:
 558     emitBlock(*static_cast<clang::doc::NamespaceInfo *>(I));
 559     break;
 560   case InfoType::IT_record:
 561     emitBlock(*static_cast<clang::doc::RecordInfo *>(I));
 562     break;
 563   case InfoType::IT_enum:
 564     emitBlock(*static_cast<clang::doc::EnumInfo *>(I));
 565     break;
 566   case InfoType::IT_function:
 567     emitBlock(*static_cast<clang::doc::FunctionInfo *>(I));
 568     break;
 569   default:
 570     llvm::errs() << "Unexpected info, unable to write.\n";
 571     return true;
 572   }
 573   return false;
 574 }
 575
 576 } // namespace doc
 577 } // namespace clang