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. Fixed-size integer (length of the following string (filename))
81        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
82                              BitCodeConstants::StringLengthSize),
83        // 2. The string blob
84        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
85 }
86 
87 struct RecordIdDsc {
88   llvm::StringRef Name;
89   AbbrevDsc Abbrev = nullptr;
90 
91   RecordIdDsc() = default;
92   RecordIdDsc(llvm::StringRef Name, AbbrevDsc Abbrev)
93       : Name(Name), Abbrev(Abbrev) {}
94 
95   // Is this 'description' valid?
96   operator bool() const {
97     return Abbrev != nullptr && Name.data() != nullptr && !Name.empty();
98   }
99 };
100 
101 static const llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor>
102     BlockIdNameMap = []() {
103       llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor> BlockIdNameMap;
104       BlockIdNameMap.resize(BlockIdCount);
105 
106       // There is no init-list constructor for the IndexedMap, so have to
107       // improvise
108       static const std::vector<std::pair<BlockId, const char *const>> Inits = {
109           {BI_VERSION_BLOCK_ID, "VersionBlock"},
110           {BI_NAMESPACE_BLOCK_ID, "NamespaceBlock"},
111           {BI_ENUM_BLOCK_ID, "EnumBlock"},
112           {BI_TYPE_BLOCK_ID, "TypeBlock"},
113           {BI_FIELD_TYPE_BLOCK_ID, "FieldTypeBlock"},
114           {BI_MEMBER_TYPE_BLOCK_ID, "MemberTypeBlock"},
115           {BI_RECORD_BLOCK_ID, "RecordBlock"},
116           {BI_FUNCTION_BLOCK_ID, "FunctionBlock"},
117           {BI_COMMENT_BLOCK_ID, "CommentBlock"},
118           {BI_REFERENCE_BLOCK_ID, "ReferenceBlock"}};
119       assert(Inits.size() == BlockIdCount);
120       for (const auto &Init : Inits)
121         BlockIdNameMap[Init.first] = Init.second;
122       assert(BlockIdNameMap.size() == BlockIdCount);
123       return BlockIdNameMap;
124     }();
125 
126 static const llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor>
127     RecordIdNameMap = []() {
128       llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor> RecordIdNameMap;
129       RecordIdNameMap.resize(RecordIdCount);
130 
131       // There is no init-list constructor for the IndexedMap, so have to
132       // improvise
133       static const std::vector<std::pair<RecordId, RecordIdDsc>> Inits = {
134           {VERSION, {"Version", &IntAbbrev}},
135           {COMMENT_KIND, {"Kind", &StringAbbrev}},
136           {COMMENT_TEXT, {"Text", &StringAbbrev}},
137           {COMMENT_NAME, {"Name", &StringAbbrev}},
138           {COMMENT_DIRECTION, {"Direction", &StringAbbrev}},
139           {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}},
140           {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}},
141           {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}},
142           {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}},
143           {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}},
144           {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}},
145           {COMMENT_ARG, {"Arg", &StringAbbrev}},
146           {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
147           {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
148           {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}},
149           {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}},
150           {NAMESPACE_NAME, {"Name", &StringAbbrev}},
151           {NAMESPACE_PATH, {"Path", &StringAbbrev}},
152           {ENUM_USR, {"USR", &SymbolIDAbbrev}},
153           {ENUM_NAME, {"Name", &StringAbbrev}},
154           {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
155           {ENUM_LOCATION, {"Location", &LocationAbbrev}},
156           {ENUM_MEMBER, {"Member", &StringAbbrev}},
157           {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
158           {RECORD_USR, {"USR", &SymbolIDAbbrev}},
159           {RECORD_NAME, {"Name", &StringAbbrev}},
160           {RECORD_PATH, {"Path", &StringAbbrev}},
161           {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
162           {RECORD_LOCATION, {"Location", &LocationAbbrev}},
163           {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
164           {RECORD_IS_TYPE_DEF, {"IsTypeDef", &BoolAbbrev}},
165           {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
166           {FUNCTION_NAME, {"Name", &StringAbbrev}},
167           {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
168           {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
169           {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
170           {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
171           {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
172           {REFERENCE_NAME, {"Name", &StringAbbrev}},
173           {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
174           {REFERENCE_PATH, {"Path", &StringAbbrev}},
175           {REFERENCE_IS_IN_GLOBAL_NAMESPACE,
176            {"IsInGlobalNamespace", &BoolAbbrev}},
177           {REFERENCE_FIELD, {"Field", &IntAbbrev}}};
178       assert(Inits.size() == RecordIdCount);
179       for (const auto &Init : Inits) {
180         RecordIdNameMap[Init.first] = Init.second;
181         assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize);
182       }
183       assert(RecordIdNameMap.size() == RecordIdCount);
184       return RecordIdNameMap;
185     }();
186 
187 static const std::vector<std::pair<BlockId, std::vector<RecordId>>>
188     RecordsByBlock{
189         // Version Block
190         {BI_VERSION_BLOCK_ID, {VERSION}},
191         // Comment Block
192         {BI_COMMENT_BLOCK_ID,
193          {COMMENT_KIND, COMMENT_TEXT, COMMENT_NAME, COMMENT_DIRECTION,
194           COMMENT_PARAMNAME, COMMENT_CLOSENAME, COMMENT_SELFCLOSING,
195           COMMENT_EXPLICIT, COMMENT_ATTRKEY, COMMENT_ATTRVAL, COMMENT_ARG}},
196         // Type Block
197         {BI_TYPE_BLOCK_ID, {}},
198         // FieldType Block
199         {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME}},
200         // MemberType Block
201         {BI_MEMBER_TYPE_BLOCK_ID, {MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}},
202         // Enum Block
203         {BI_ENUM_BLOCK_ID,
204          {ENUM_USR, ENUM_NAME, ENUM_DEFLOCATION, ENUM_LOCATION, ENUM_MEMBER,
205           ENUM_SCOPED}},
206         // Namespace Block
207         {BI_NAMESPACE_BLOCK_ID,
208          {NAMESPACE_USR, NAMESPACE_NAME, NAMESPACE_PATH}},
209         // Record Block
210         {BI_RECORD_BLOCK_ID,
211          {RECORD_USR, RECORD_NAME, RECORD_PATH, RECORD_DEFLOCATION,
212           RECORD_LOCATION, RECORD_TAG_TYPE, RECORD_IS_TYPE_DEF}},
213         // Function Block
214         {BI_FUNCTION_BLOCK_ID,
215          {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION,
216           FUNCTION_ACCESS, FUNCTION_IS_METHOD}},
217         // Reference Block
218         {BI_REFERENCE_BLOCK_ID,
219          {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_PATH,
220           REFERENCE_IS_IN_GLOBAL_NAMESPACE, REFERENCE_FIELD}}};
221 
222 // AbbreviationMap
223 
224 constexpr unsigned char BitCodeConstants::Signature[];
225 
226 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
227                                                  unsigned AbbrevID) {
228   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
229   assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added.");
230   Abbrevs[RID] = AbbrevID;
231 }
232 
233 unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const {
234   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
235   assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation.");
236   return Abbrevs.lookup(RID);
237 }
238 
239 // Validation and Overview Blocks
240 
241 /// \brief Emits the magic number header to check that its the right format,
242 /// in this case, 'DOCS'.
243 void ClangDocBitcodeWriter::emitHeader() {
244   for (char C : BitCodeConstants::Signature)
245     Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize);
246 }
247 
248 void ClangDocBitcodeWriter::emitVersionBlock() {
249   StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID);
250   emitRecord(VersionNumber, VERSION);
251 }
252 
253 /// \brief Emits a block ID and the block name to the BLOCKINFO block.
254 void ClangDocBitcodeWriter::emitBlockID(BlockId BID) {
255   const auto &BlockIdName = BlockIdNameMap[BID];
256   assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId.");
257 
258   Record.clear();
259   Record.push_back(BID);
260   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
261   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
262                     ArrayRef<unsigned char>(BlockIdName.bytes_begin(),
263                                             BlockIdName.bytes_end()));
264 }
265 
266 /// \brief Emits a record name to the BLOCKINFO block.
267 void ClangDocBitcodeWriter::emitRecordID(RecordId ID) {
268   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
269   prepRecordData(ID);
270   Record.append(RecordIdNameMap[ID].Name.begin(),
271                 RecordIdNameMap[ID].Name.end());
272   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
273 }
274 
275 // Abbreviations
276 
277 void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId Block) {
278   assert(RecordIdNameMap[ID] && "Unknown abbreviation.");
279   auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>();
280   Abbrev->Add(llvm::BitCodeAbbrevOp(ID));
281   RecordIdNameMap[ID].Abbrev(Abbrev);
282   Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev)));
283 }
284 
285 // Records
286 
287 void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) {
288   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
289   assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev &&
290          "Abbrev type mismatch.");
291   if (!prepRecordData(ID, Sym != EmptySID))
292     return;
293   assert(Sym.size() == 20);
294   Record.push_back(Sym.size());
295   Record.append(Sym.begin(), Sym.end());
296   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
297 }
298 
299 void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) {
300   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
301   assert(RecordIdNameMap[ID].Abbrev == &StringAbbrev &&
302          "Abbrev type mismatch.");
303   if (!prepRecordData(ID, !Str.empty()))
304     return;
305   assert(Str.size() < (1U << BitCodeConstants::StringLengthSize));
306   Record.push_back(Str.size());
307   Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Str);
308 }
309 
310 void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) {
311   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
312   assert(RecordIdNameMap[ID].Abbrev == &LocationAbbrev &&
313          "Abbrev type mismatch.");
314   if (!prepRecordData(ID, true))
315     return;
316   // FIXME: Assert that the line number is of the appropriate size.
317   Record.push_back(Loc.LineNumber);
318   assert(Loc.Filename.size() < (1U << BitCodeConstants::StringLengthSize));
319   Record.push_back(Loc.Filename.size());
320   Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Loc.Filename);
321 }
322 
323 void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) {
324   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
325   assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch.");
326   if (!prepRecordData(ID, Val))
327     return;
328   Record.push_back(Val);
329   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
330 }
331 
332 void ClangDocBitcodeWriter::emitRecord(int Val, RecordId ID) {
333   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
334   assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
335   if (!prepRecordData(ID, Val))
336     return;
337   // FIXME: Assert that the integer is of the appropriate size.
338   Record.push_back(Val);
339   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
340 }
341 
342 void ClangDocBitcodeWriter::emitRecord(unsigned Val, RecordId ID) {
343   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
344   assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
345   if (!prepRecordData(ID, Val))
346     return;
347   assert(Val < (1U << BitCodeConstants::IntSize));
348   Record.push_back(Val);
349   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
350 }
351 
352 bool ClangDocBitcodeWriter::prepRecordData(RecordId ID, bool ShouldEmit) {
353   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
354   if (!ShouldEmit)
355     return false;
356   Record.clear();
357   Record.push_back(ID);
358   return true;
359 }
360 
361 // BlockInfo Block
362 
363 void ClangDocBitcodeWriter::emitBlockInfoBlock() {
364   Stream.EnterBlockInfoBlock();
365   for (const auto &Block : RecordsByBlock) {
366     assert(Block.second.size() < (1U << BitCodeConstants::SubblockIDSize));
367     emitBlockInfo(Block.first, Block.second);
368   }
369   Stream.ExitBlock();
370 }
371 
372 void ClangDocBitcodeWriter::emitBlockInfo(BlockId BID,
373                                           const std::vector<RecordId> &RIDs) {
374   assert(RIDs.size() < (1U << BitCodeConstants::SubblockIDSize));
375   emitBlockID(BID);
376   for (RecordId RID : RIDs) {
377     emitRecordID(RID);
378     emitAbbrev(RID, BID);
379   }
380 }
381 
382 // Block emission
383 
384 void ClangDocBitcodeWriter::emitBlock(const Reference &R, FieldId Field) {
385   if (R.USR == EmptySID && R.Name.empty())
386     return;
387   StreamSubBlockGuard Block(Stream, BI_REFERENCE_BLOCK_ID);
388   emitRecord(R.USR, REFERENCE_USR);
389   emitRecord(R.Name, REFERENCE_NAME);
390   emitRecord((unsigned)R.RefType, REFERENCE_TYPE);
391   emitRecord(R.Path, REFERENCE_PATH);
392   emitRecord(R.IsInGlobalNamespace, REFERENCE_IS_IN_GLOBAL_NAMESPACE);
393   emitRecord((unsigned)Field, REFERENCE_FIELD);
394 }
395 
396 void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) {
397   StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID);
398   emitBlock(T.Type, FieldId::F_type);
399 }
400 
401 void ClangDocBitcodeWriter::emitBlock(const FieldTypeInfo &T) {
402   StreamSubBlockGuard Block(Stream, BI_FIELD_TYPE_BLOCK_ID);
403   emitBlock(T.Type, FieldId::F_type);
404   emitRecord(T.Name, FIELD_TYPE_NAME);
405 }
406 
407 void ClangDocBitcodeWriter::emitBlock(const MemberTypeInfo &T) {
408   StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID);
409   emitBlock(T.Type, FieldId::F_type);
410   emitRecord(T.Name, MEMBER_TYPE_NAME);
411   emitRecord(T.Access, MEMBER_TYPE_ACCESS);
412 }
413 
414 void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) {
415   StreamSubBlockGuard Block(Stream, BI_COMMENT_BLOCK_ID);
416   for (const auto &L : std::vector<std::pair<llvm::StringRef, RecordId>>{
417            {I.Kind, COMMENT_KIND},
418            {I.Text, COMMENT_TEXT},
419            {I.Name, COMMENT_NAME},
420            {I.Direction, COMMENT_DIRECTION},
421            {I.ParamName, COMMENT_PARAMNAME},
422            {I.CloseName, COMMENT_CLOSENAME}})
423     emitRecord(L.first, L.second);
424   emitRecord(I.SelfClosing, COMMENT_SELFCLOSING);
425   emitRecord(I.Explicit, COMMENT_EXPLICIT);
426   for (const auto &A : I.AttrKeys)
427     emitRecord(A, COMMENT_ATTRKEY);
428   for (const auto &A : I.AttrValues)
429     emitRecord(A, COMMENT_ATTRVAL);
430   for (const auto &A : I.Args)
431     emitRecord(A, COMMENT_ARG);
432   for (const auto &C : I.Children)
433     emitBlock(*C);
434 }
435 
436 void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) {
437   StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID);
438   emitRecord(I.USR, NAMESPACE_USR);
439   emitRecord(I.Name, NAMESPACE_NAME);
440   emitRecord(I.Path, NAMESPACE_PATH);
441   for (const auto &N : I.Namespace)
442     emitBlock(N, FieldId::F_namespace);
443   for (const auto &CI : I.Description)
444     emitBlock(CI);
445   for (const auto &C : I.ChildNamespaces)
446     emitBlock(C, FieldId::F_child_namespace);
447   for (const auto &C : I.ChildRecords)
448     emitBlock(C, FieldId::F_child_record);
449   for (const auto &C : I.ChildFunctions)
450     emitBlock(C);
451   for (const auto &C : I.ChildEnums)
452     emitBlock(C);
453 }
454 
455 void ClangDocBitcodeWriter::emitBlock(const EnumInfo &I) {
456   StreamSubBlockGuard Block(Stream, BI_ENUM_BLOCK_ID);
457   emitRecord(I.USR, ENUM_USR);
458   emitRecord(I.Name, ENUM_NAME);
459   for (const auto &N : I.Namespace)
460     emitBlock(N, FieldId::F_namespace);
461   for (const auto &CI : I.Description)
462     emitBlock(CI);
463   if (I.DefLoc)
464     emitRecord(I.DefLoc.getValue(), ENUM_DEFLOCATION);
465   for (const auto &L : I.Loc)
466     emitRecord(L, ENUM_LOCATION);
467   emitRecord(I.Scoped, ENUM_SCOPED);
468   for (const auto &N : I.Members)
469     emitRecord(N, ENUM_MEMBER);
470 }
471 
472 void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
473   StreamSubBlockGuard Block(Stream, BI_RECORD_BLOCK_ID);
474   emitRecord(I.USR, RECORD_USR);
475   emitRecord(I.Name, RECORD_NAME);
476   emitRecord(I.Path, RECORD_PATH);
477   for (const auto &N : I.Namespace)
478     emitBlock(N, FieldId::F_namespace);
479   for (const auto &CI : I.Description)
480     emitBlock(CI);
481   if (I.DefLoc)
482     emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION);
483   for (const auto &L : I.Loc)
484     emitRecord(L, RECORD_LOCATION);
485   emitRecord(I.TagType, RECORD_TAG_TYPE);
486   emitRecord(I.IsTypeDef, RECORD_IS_TYPE_DEF);
487   for (const auto &N : I.Members)
488     emitBlock(N);
489   for (const auto &P : I.Parents)
490     emitBlock(P, FieldId::F_parent);
491   for (const auto &P : I.VirtualParents)
492     emitBlock(P, FieldId::F_vparent);
493   for (const auto &C : I.ChildRecords)
494     emitBlock(C, FieldId::F_child_record);
495   for (const auto &C : I.ChildFunctions)
496     emitBlock(C);
497   for (const auto &C : I.ChildEnums)
498     emitBlock(C);
499 }
500 
501 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
502   StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
503   emitRecord(I.USR, FUNCTION_USR);
504   emitRecord(I.Name, FUNCTION_NAME);
505   for (const auto &N : I.Namespace)
506     emitBlock(N, FieldId::F_namespace);
507   for (const auto &CI : I.Description)
508     emitBlock(CI);
509   emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
510   if (I.DefLoc)
511     emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION);
512   for (const auto &L : I.Loc)
513     emitRecord(L, FUNCTION_LOCATION);
514   emitBlock(I.Parent, FieldId::F_parent);
515   emitBlock(I.ReturnType);
516   for (const auto &N : I.Params)
517     emitBlock(N);
518 }
519 
520 bool ClangDocBitcodeWriter::dispatchInfoForWrite(Info *I) {
521   switch (I->IT) {
522   case InfoType::IT_namespace:
523     emitBlock(*static_cast<clang::doc::NamespaceInfo *>(I));
524     break;
525   case InfoType::IT_record:
526     emitBlock(*static_cast<clang::doc::RecordInfo *>(I));
527     break;
528   case InfoType::IT_enum:
529     emitBlock(*static_cast<clang::doc::EnumInfo *>(I));
530     break;
531   case InfoType::IT_function:
532     emitBlock(*static_cast<clang::doc::FunctionInfo *>(I));
533     break;
534   default:
535     llvm::errs() << "Unexpected info, unable to write.\n";
536     return true;
537   }
538   return false;
539 }
540 
541 } // namespace doc
542 } // namespace clang
543