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