1 //===--  BitcodeReader.cpp - ClangDoc Bitcode Reader ------------*- 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 "BitcodeReader.h"
10 #include "llvm/ADT/IndexedMap.h"
11 #include "llvm/ADT/Optional.h"
12 #include "llvm/Support/Error.h"
13 #include "llvm/Support/raw_ostream.h"
14 
15 namespace clang {
16 namespace doc {
17 
18 using Record = llvm::SmallVector<uint64_t, 1024>;
19 
20 llvm::Error decodeRecord(Record R, llvm::SmallVectorImpl<char> &Field,
21                          llvm::StringRef Blob) {
22   Field.assign(Blob.begin(), Blob.end());
23   return llvm::Error::success();
24 }
25 
26 llvm::Error decodeRecord(Record R, SymbolID &Field, llvm::StringRef Blob) {
27   if (R[0] != BitCodeConstants::USRHashSize)
28     return llvm::make_error<llvm::StringError>("Incorrect USR size.\n",
29                                                llvm::inconvertibleErrorCode());
30 
31   // First position in the record is the length of the following array, so we
32   // copy the following elements to the field.
33   for (int I = 0, E = R[0]; I < E; ++I)
34     Field[I] = R[I + 1];
35   return llvm::Error::success();
36 }
37 
38 llvm::Error decodeRecord(Record R, bool &Field, llvm::StringRef Blob) {
39   Field = R[0] != 0;
40   return llvm::Error::success();
41 }
42 
43 llvm::Error decodeRecord(Record R, int &Field, llvm::StringRef Blob) {
44   if (R[0] > INT_MAX)
45     return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
46                                                llvm::inconvertibleErrorCode());
47   Field = (int)R[0];
48   return llvm::Error::success();
49 }
50 
51 llvm::Error decodeRecord(Record R, AccessSpecifier &Field,
52                          llvm::StringRef Blob) {
53   switch (R[0]) {
54   case AS_public:
55   case AS_private:
56   case AS_protected:
57   case AS_none:
58     Field = (AccessSpecifier)R[0];
59     return llvm::Error::success();
60   default:
61     return llvm::make_error<llvm::StringError>(
62         "Invalid value for AccessSpecifier.\n", llvm::inconvertibleErrorCode());
63   }
64 }
65 
66 llvm::Error decodeRecord(Record R, TagTypeKind &Field, llvm::StringRef Blob) {
67   switch (R[0]) {
68   case TTK_Struct:
69   case TTK_Interface:
70   case TTK_Union:
71   case TTK_Class:
72   case TTK_Enum:
73     Field = (TagTypeKind)R[0];
74     return llvm::Error::success();
75   default:
76     return llvm::make_error<llvm::StringError>(
77         "Invalid value for TagTypeKind.\n", llvm::inconvertibleErrorCode());
78   }
79 }
80 
81 llvm::Error decodeRecord(Record R, llvm::Optional<Location> &Field,
82                          llvm::StringRef Blob) {
83   if (R[0] > INT_MAX)
84     return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
85                                                llvm::inconvertibleErrorCode());
86   Field.emplace((int)R[0], Blob);
87   return llvm::Error::success();
88 }
89 
90 llvm::Error decodeRecord(Record R, InfoType &Field, llvm::StringRef Blob) {
91   switch (auto IT = static_cast<InfoType>(R[0])) {
92   case InfoType::IT_namespace:
93   case InfoType::IT_record:
94   case InfoType::IT_function:
95   case InfoType::IT_default:
96   case InfoType::IT_enum:
97     Field = IT;
98     return llvm::Error::success();
99   }
100   return llvm::make_error<llvm::StringError>("Invalid value for InfoType.\n",
101                                              llvm::inconvertibleErrorCode());
102 }
103 
104 llvm::Error decodeRecord(Record R, FieldId &Field, llvm::StringRef Blob) {
105   switch (auto F = static_cast<FieldId>(R[0])) {
106   case FieldId::F_namespace:
107   case FieldId::F_parent:
108   case FieldId::F_vparent:
109   case FieldId::F_type:
110   case FieldId::F_child_namespace:
111   case FieldId::F_child_record:
112   case FieldId::F_default:
113     Field = F;
114     return llvm::Error::success();
115   }
116   return llvm::make_error<llvm::StringError>("Invalid value for FieldId.\n",
117                                              llvm::inconvertibleErrorCode());
118 }
119 
120 llvm::Error decodeRecord(Record R,
121                          llvm::SmallVectorImpl<llvm::SmallString<16>> &Field,
122                          llvm::StringRef Blob) {
123   Field.push_back(Blob);
124   return llvm::Error::success();
125 }
126 
127 llvm::Error decodeRecord(Record R, llvm::SmallVectorImpl<Location> &Field,
128                          llvm::StringRef Blob) {
129   if (R[0] > INT_MAX)
130     return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
131                                                llvm::inconvertibleErrorCode());
132   Field.emplace_back((int)R[0], Blob);
133   return llvm::Error::success();
134 }
135 
136 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
137                         const unsigned VersionNo) {
138   if (ID == VERSION && R[0] == VersionNo)
139     return llvm::Error::success();
140   return llvm::make_error<llvm::StringError>(
141       "Mismatched bitcode version number.\n", llvm::inconvertibleErrorCode());
142 }
143 
144 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
145                         NamespaceInfo *I) {
146   switch (ID) {
147   case NAMESPACE_USR:
148     return decodeRecord(R, I->USR, Blob);
149   case NAMESPACE_NAME:
150     return decodeRecord(R, I->Name, Blob);
151   default:
152     return llvm::make_error<llvm::StringError>(
153         "Invalid field for NamespaceInfo.\n", llvm::inconvertibleErrorCode());
154   }
155 }
156 
157 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
158                         RecordInfo *I) {
159   switch (ID) {
160   case RECORD_USR:
161     return decodeRecord(R, I->USR, Blob);
162   case RECORD_NAME:
163     return decodeRecord(R, I->Name, Blob);
164   case RECORD_DEFLOCATION:
165     return decodeRecord(R, I->DefLoc, Blob);
166   case RECORD_LOCATION:
167     return decodeRecord(R, I->Loc, Blob);
168   case RECORD_TAG_TYPE:
169     return decodeRecord(R, I->TagType, Blob);
170   default:
171     return llvm::make_error<llvm::StringError>(
172         "Invalid field for RecordInfo.\n", llvm::inconvertibleErrorCode());
173   }
174 }
175 
176 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
177                         EnumInfo *I) {
178   switch (ID) {
179   case ENUM_USR:
180     return decodeRecord(R, I->USR, Blob);
181   case ENUM_NAME:
182     return decodeRecord(R, I->Name, Blob);
183   case ENUM_DEFLOCATION:
184     return decodeRecord(R, I->DefLoc, Blob);
185   case ENUM_LOCATION:
186     return decodeRecord(R, I->Loc, Blob);
187   case ENUM_MEMBER:
188     return decodeRecord(R, I->Members, Blob);
189   case ENUM_SCOPED:
190     return decodeRecord(R, I->Scoped, Blob);
191   default:
192     return llvm::make_error<llvm::StringError>("Invalid field for EnumInfo.\n",
193                                                llvm::inconvertibleErrorCode());
194   }
195 }
196 
197 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
198                         FunctionInfo *I) {
199   switch (ID) {
200   case FUNCTION_USR:
201     return decodeRecord(R, I->USR, Blob);
202   case FUNCTION_NAME:
203     return decodeRecord(R, I->Name, Blob);
204   case FUNCTION_DEFLOCATION:
205     return decodeRecord(R, I->DefLoc, Blob);
206   case FUNCTION_LOCATION:
207     return decodeRecord(R, I->Loc, Blob);
208   case FUNCTION_ACCESS:
209     return decodeRecord(R, I->Access, Blob);
210   case FUNCTION_IS_METHOD:
211     return decodeRecord(R, I->IsMethod, Blob);
212   default:
213     return llvm::make_error<llvm::StringError>(
214         "Invalid field for FunctionInfo.\n", llvm::inconvertibleErrorCode());
215   }
216 }
217 
218 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
219                         TypeInfo *I) {
220   return llvm::Error::success();
221 }
222 
223 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
224                         FieldTypeInfo *I) {
225   switch (ID) {
226   case FIELD_TYPE_NAME:
227     return decodeRecord(R, I->Name, Blob);
228   default:
229     return llvm::make_error<llvm::StringError>("Invalid field for TypeInfo.\n",
230                                                llvm::inconvertibleErrorCode());
231   }
232 }
233 
234 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
235                         MemberTypeInfo *I) {
236   switch (ID) {
237   case MEMBER_TYPE_NAME:
238     return decodeRecord(R, I->Name, Blob);
239   case MEMBER_TYPE_ACCESS:
240     return decodeRecord(R, I->Access, Blob);
241   default:
242     return llvm::make_error<llvm::StringError>(
243         "Invalid field for MemberTypeInfo.\n", llvm::inconvertibleErrorCode());
244   }
245 }
246 
247 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
248                         CommentInfo *I) {
249   switch (ID) {
250   case COMMENT_KIND:
251     return decodeRecord(R, I->Kind, Blob);
252   case COMMENT_TEXT:
253     return decodeRecord(R, I->Text, Blob);
254   case COMMENT_NAME:
255     return decodeRecord(R, I->Name, Blob);
256   case COMMENT_DIRECTION:
257     return decodeRecord(R, I->Direction, Blob);
258   case COMMENT_PARAMNAME:
259     return decodeRecord(R, I->ParamName, Blob);
260   case COMMENT_CLOSENAME:
261     return decodeRecord(R, I->CloseName, Blob);
262   case COMMENT_ATTRKEY:
263     return decodeRecord(R, I->AttrKeys, Blob);
264   case COMMENT_ATTRVAL:
265     return decodeRecord(R, I->AttrValues, Blob);
266   case COMMENT_ARG:
267     return decodeRecord(R, I->Args, Blob);
268   case COMMENT_SELFCLOSING:
269     return decodeRecord(R, I->SelfClosing, Blob);
270   case COMMENT_EXPLICIT:
271     return decodeRecord(R, I->Explicit, Blob);
272   default:
273     return llvm::make_error<llvm::StringError>(
274         "Invalid field for CommentInfo.\n", llvm::inconvertibleErrorCode());
275   }
276 }
277 
278 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
279                         Reference *I, FieldId &F) {
280   switch (ID) {
281   case REFERENCE_USR:
282     return decodeRecord(R, I->USR, Blob);
283   case REFERENCE_NAME:
284     return decodeRecord(R, I->Name, Blob);
285   case REFERENCE_TYPE:
286     return decodeRecord(R, I->RefType, Blob);
287   case REFERENCE_FIELD:
288     return decodeRecord(R, F, Blob);
289   default:
290     return llvm::make_error<llvm::StringError>("Invalid field for Reference.\n",
291                                                llvm::inconvertibleErrorCode());
292   }
293 }
294 
295 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
296   return llvm::make_error<llvm::StringError>(
297       "Invalid type cannot contain CommentInfo.\n",
298       llvm::inconvertibleErrorCode());
299 }
300 
301 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
302   I->Description.emplace_back();
303   return &I->Description.back();
304 }
305 
306 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {
307   I->Description.emplace_back();
308   return &I->Description.back();
309 }
310 
311 template <> llvm::Expected<CommentInfo *> getCommentInfo(RecordInfo *I) {
312   I->Description.emplace_back();
313   return &I->Description.back();
314 }
315 
316 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumInfo *I) {
317   I->Description.emplace_back();
318   return &I->Description.back();
319 }
320 
321 template <> llvm::Expected<CommentInfo *> getCommentInfo(CommentInfo *I) {
322   I->Children.emplace_back(llvm::make_unique<CommentInfo>());
323   return I->Children.back().get();
324 }
325 
326 template <>
327 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
328   return getCommentInfo(I.get());
329 }
330 
331 template <typename T, typename TTypeInfo>
332 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
333   return llvm::make_error<llvm::StringError>(
334       "Invalid type cannot contain TypeInfo.\n",
335       llvm::inconvertibleErrorCode());
336 }
337 
338 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
339   I->Members.emplace_back(std::move(T));
340   return llvm::Error::success();
341 }
342 
343 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
344   I->ReturnType = std::move(T);
345   return llvm::Error::success();
346 }
347 
348 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
349   I->Params.emplace_back(std::move(T));
350   return llvm::Error::success();
351 }
352 
353 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
354   return llvm::make_error<llvm::StringError>(
355       "Invalid type cannot contain Reference\n",
356       llvm::inconvertibleErrorCode());
357 }
358 
359 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
360   switch (F) {
361   case FieldId::F_type:
362     I->Type = std::move(R);
363     return llvm::Error::success();
364   default:
365     return llvm::make_error<llvm::StringError>(
366         "Invalid type cannot contain Reference.\n",
367         llvm::inconvertibleErrorCode());
368   }
369 }
370 
371 template <>
372 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
373   switch (F) {
374   case FieldId::F_type:
375     I->Type = std::move(R);
376     return llvm::Error::success();
377   default:
378     return llvm::make_error<llvm::StringError>(
379         "Invalid type cannot contain Reference.\n",
380         llvm::inconvertibleErrorCode());
381   }
382 }
383 
384 template <>
385 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
386   switch (F) {
387   case FieldId::F_type:
388     I->Type = std::move(R);
389     return llvm::Error::success();
390   default:
391     return llvm::make_error<llvm::StringError>(
392         "Invalid type cannot contain Reference.\n",
393         llvm::inconvertibleErrorCode());
394   }
395 }
396 
397 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
398   switch (F) {
399   case FieldId::F_namespace:
400     I->Namespace.emplace_back(std::move(R));
401     return llvm::Error::success();
402   default:
403     return llvm::make_error<llvm::StringError>(
404         "Invalid type cannot contain Reference.\n",
405         llvm::inconvertibleErrorCode());
406   }
407 }
408 
409 template <>
410 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
411   switch (F) {
412   case FieldId::F_namespace:
413     I->Namespace.emplace_back(std::move(R));
414     return llvm::Error::success();
415   case FieldId::F_child_namespace:
416     I->ChildNamespaces.emplace_back(std::move(R));
417     return llvm::Error::success();
418   case FieldId::F_child_record:
419     I->ChildRecords.emplace_back(std::move(R));
420     return llvm::Error::success();
421   default:
422     return llvm::make_error<llvm::StringError>(
423         "Invalid type cannot contain Reference.\n",
424         llvm::inconvertibleErrorCode());
425   }
426 }
427 
428 template <>
429 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
430   switch (F) {
431   case FieldId::F_namespace:
432     I->Namespace.emplace_back(std::move(R));
433     return llvm::Error::success();
434   case FieldId::F_parent:
435     I->Parent = std::move(R);
436     return llvm::Error::success();
437   default:
438     return llvm::make_error<llvm::StringError>(
439         "Invalid type cannot contain Reference.\n",
440         llvm::inconvertibleErrorCode());
441   }
442 }
443 
444 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
445   switch (F) {
446   case FieldId::F_namespace:
447     I->Namespace.emplace_back(std::move(R));
448     return llvm::Error::success();
449   case FieldId::F_parent:
450     I->Parents.emplace_back(std::move(R));
451     return llvm::Error::success();
452   case FieldId::F_vparent:
453     I->VirtualParents.emplace_back(std::move(R));
454     return llvm::Error::success();
455   case FieldId::F_child_record:
456     I->ChildRecords.emplace_back(std::move(R));
457     return llvm::Error::success();
458   default:
459     return llvm::make_error<llvm::StringError>(
460         "Invalid type cannot contain Reference.\n",
461         llvm::inconvertibleErrorCode());
462   }
463 }
464 
465 template <typename T, typename ChildInfoType>
466 void addChild(T I, ChildInfoType &&R) {
467   llvm::errs() << "Invalid child type for info.\n";
468   exit(1);
469 }
470 
471 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
472   I->ChildFunctions.emplace_back(std::move(R));
473 }
474 
475 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
476   I->ChildEnums.emplace_back(std::move(R));
477 }
478 
479 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
480   I->ChildFunctions.emplace_back(std::move(R));
481 }
482 
483 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
484   I->ChildEnums.emplace_back(std::move(R));
485 }
486 
487 // Read records from bitcode into a given info.
488 template <typename T>
489 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
490   Record R;
491   llvm::StringRef Blob;
492   unsigned RecID = Stream.readRecord(ID, R, &Blob);
493   return parseRecord(R, RecID, Blob, I);
494 }
495 
496 template <>
497 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
498   Record R;
499   llvm::StringRef Blob;
500   unsigned RecID = Stream.readRecord(ID, R, &Blob);
501   return parseRecord(R, RecID, Blob, I, CurrentReferenceField);
502 }
503 
504 // Read a block of records into a single info.
505 template <typename T>
506 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
507   if (Stream.EnterSubBlock(ID))
508     return llvm::make_error<llvm::StringError>("Unable to enter subblock.\n",
509                                                llvm::inconvertibleErrorCode());
510 
511   while (true) {
512     unsigned BlockOrCode = 0;
513     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
514 
515     switch (Res) {
516     case Cursor::BadBlock:
517       return llvm::make_error<llvm::StringError>(
518           "Bad block found.\n", llvm::inconvertibleErrorCode());
519     case Cursor::BlockEnd:
520       return llvm::Error::success();
521     case Cursor::BlockBegin:
522       if (auto Err = readSubBlock(BlockOrCode, I)) {
523         if (!Stream.SkipBlock())
524           continue;
525         return Err;
526       }
527       continue;
528     case Cursor::Record:
529       break;
530     }
531     if (auto Err = readRecord(BlockOrCode, I))
532       return Err;
533   }
534 }
535 
536 template <typename T>
537 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
538   switch (ID) {
539   // Blocks can only have Comment, Reference, TypeInfo, FunctionInfo, or
540   // EnumInfo subblocks
541   case BI_COMMENT_BLOCK_ID: {
542     auto Comment = getCommentInfo(I);
543     if (!Comment)
544       return Comment.takeError();
545     if (auto Err = readBlock(ID, Comment.get()))
546       return Err;
547     return llvm::Error::success();
548   }
549   case BI_TYPE_BLOCK_ID: {
550     TypeInfo TI;
551     if (auto Err = readBlock(ID, &TI))
552       return Err;
553     if (auto Err = addTypeInfo(I, std::move(TI)))
554       return Err;
555     return llvm::Error::success();
556   }
557   case BI_FIELD_TYPE_BLOCK_ID: {
558     FieldTypeInfo TI;
559     if (auto Err = readBlock(ID, &TI))
560       return Err;
561     if (auto Err = addTypeInfo(I, std::move(TI)))
562       return Err;
563     return llvm::Error::success();
564   }
565   case BI_MEMBER_TYPE_BLOCK_ID: {
566     MemberTypeInfo TI;
567     if (auto Err = readBlock(ID, &TI))
568       return Err;
569     if (auto Err = addTypeInfo(I, std::move(TI)))
570       return Err;
571     return llvm::Error::success();
572   }
573   case BI_REFERENCE_BLOCK_ID: {
574     Reference R;
575     if (auto Err = readBlock(ID, &R))
576       return Err;
577     if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
578       return Err;
579     return llvm::Error::success();
580   }
581   case BI_FUNCTION_BLOCK_ID: {
582     FunctionInfo F;
583     if (auto Err = readBlock(ID, &F))
584       return Err;
585     addChild(I, std::move(F));
586     return llvm::Error::success();
587   }
588   case BI_ENUM_BLOCK_ID: {
589     EnumInfo E;
590     if (auto Err = readBlock(ID, &E))
591       return Err;
592     addChild(I, std::move(E));
593     return llvm::Error::success();
594   }
595   default:
596     return llvm::make_error<llvm::StringError>("Invalid subblock type.\n",
597                                                llvm::inconvertibleErrorCode());
598   }
599 }
600 
601 ClangDocBitcodeReader::Cursor
602 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
603   BlockOrRecordID = 0;
604 
605   while (!Stream.AtEndOfStream()) {
606     unsigned Code = Stream.ReadCode();
607 
608     switch ((llvm::bitc::FixedAbbrevIDs)Code) {
609     case llvm::bitc::ENTER_SUBBLOCK:
610       BlockOrRecordID = Stream.ReadSubBlockID();
611       return Cursor::BlockBegin;
612     case llvm::bitc::END_BLOCK:
613       if (Stream.ReadBlockEnd())
614         return Cursor::BadBlock;
615       return Cursor::BlockEnd;
616     case llvm::bitc::DEFINE_ABBREV:
617       Stream.ReadAbbrevRecord();
618       continue;
619     case llvm::bitc::UNABBREV_RECORD:
620       return Cursor::BadBlock;
621     default:
622       BlockOrRecordID = Code;
623       return Cursor::Record;
624     }
625   }
626   llvm_unreachable("Premature stream end.");
627 }
628 
629 llvm::Error ClangDocBitcodeReader::validateStream() {
630   if (Stream.AtEndOfStream())
631     return llvm::make_error<llvm::StringError>("Premature end of stream.\n",
632                                                llvm::inconvertibleErrorCode());
633 
634   // Sniff for the signature.
635   if (Stream.Read(8) != BitCodeConstants::Signature[0] ||
636       Stream.Read(8) != BitCodeConstants::Signature[1] ||
637       Stream.Read(8) != BitCodeConstants::Signature[2] ||
638       Stream.Read(8) != BitCodeConstants::Signature[3])
639     return llvm::make_error<llvm::StringError>("Invalid bitcode signature.\n",
640                                                llvm::inconvertibleErrorCode());
641   return llvm::Error::success();
642 }
643 
644 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
645   BlockInfo = Stream.ReadBlockInfoBlock();
646   if (!BlockInfo)
647     return llvm::make_error<llvm::StringError>(
648         "Unable to parse BlockInfoBlock.\n", llvm::inconvertibleErrorCode());
649   Stream.setBlockInfo(&*BlockInfo);
650   return llvm::Error::success();
651 }
652 
653 template <typename T>
654 llvm::Expected<std::unique_ptr<Info>>
655 ClangDocBitcodeReader::createInfo(unsigned ID) {
656   std::unique_ptr<Info> I = llvm::make_unique<T>();
657   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
658     return std::move(Err);
659   return std::unique_ptr<Info>{std::move(I)};;
660 }
661 
662 llvm::Expected<std::unique_ptr<Info>>
663 ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
664   switch (ID) {
665   case BI_NAMESPACE_BLOCK_ID:
666     return createInfo<NamespaceInfo>(ID);
667   case BI_RECORD_BLOCK_ID:
668     return createInfo<RecordInfo>(ID);
669   case BI_ENUM_BLOCK_ID:
670     return createInfo<EnumInfo>(ID);
671   case BI_FUNCTION_BLOCK_ID:
672     return createInfo<FunctionInfo>(ID);
673   default:
674     return llvm::make_error<llvm::StringError>("Cannot create info.\n",
675                                                llvm::inconvertibleErrorCode());
676   }
677 }
678 
679 // Entry point
680 llvm::Expected<std::vector<std::unique_ptr<Info>>>
681 ClangDocBitcodeReader::readBitcode() {
682   std::vector<std::unique_ptr<Info>> Infos;
683   if (auto Err = validateStream())
684     return std::move(Err);
685 
686   // Read the top level blocks.
687   while (!Stream.AtEndOfStream()) {
688     unsigned Code = Stream.ReadCode();
689     if (Code != llvm::bitc::ENTER_SUBBLOCK)
690       return llvm::make_error<llvm::StringError>(
691           "No blocks in input.\n", llvm::inconvertibleErrorCode());
692     unsigned ID = Stream.ReadSubBlockID();
693     switch (ID) {
694     // NamedType and Comment blocks should not appear at the top level
695     case BI_TYPE_BLOCK_ID:
696     case BI_FIELD_TYPE_BLOCK_ID:
697     case BI_MEMBER_TYPE_BLOCK_ID:
698     case BI_COMMENT_BLOCK_ID:
699     case BI_REFERENCE_BLOCK_ID:
700       return llvm::make_error<llvm::StringError>(
701           "Invalid top level block.\n", llvm::inconvertibleErrorCode());
702     case BI_NAMESPACE_BLOCK_ID:
703     case BI_RECORD_BLOCK_ID:
704     case BI_ENUM_BLOCK_ID:
705     case BI_FUNCTION_BLOCK_ID: {
706       auto InfoOrErr = readBlockToInfo(ID);
707       if (!InfoOrErr)
708         return InfoOrErr.takeError();
709       Infos.emplace_back(std::move(InfoOrErr.get()));
710       continue;
711     }
712     case BI_VERSION_BLOCK_ID:
713       if (auto Err = readBlock(ID, VersionNumber))
714         return std::move(Err);
715       continue;
716     case llvm::bitc::BLOCKINFO_BLOCK_ID:
717       if (auto Err = readBlockInfoBlock())
718         return std::move(Err);
719       continue;
720     default:
721       if (!Stream.SkipBlock())
722         continue;
723     }
724   }
725   return std::move(Infos);
726 }
727 
728 } // namespace doc
729 } // namespace clang
730