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   case RECORD_IS_TYPE_DEF:
171     return decodeRecord(R, I->IsTypeDef, Blob);
172   default:
173     return llvm::make_error<llvm::StringError>(
174         "Invalid field for RecordInfo.\n", llvm::inconvertibleErrorCode());
175   }
176 }
177 
178 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
179                         EnumInfo *I) {
180   switch (ID) {
181   case ENUM_USR:
182     return decodeRecord(R, I->USR, Blob);
183   case ENUM_NAME:
184     return decodeRecord(R, I->Name, Blob);
185   case ENUM_DEFLOCATION:
186     return decodeRecord(R, I->DefLoc, Blob);
187   case ENUM_LOCATION:
188     return decodeRecord(R, I->Loc, Blob);
189   case ENUM_MEMBER:
190     return decodeRecord(R, I->Members, Blob);
191   case ENUM_SCOPED:
192     return decodeRecord(R, I->Scoped, Blob);
193   default:
194     return llvm::make_error<llvm::StringError>("Invalid field for EnumInfo.\n",
195                                                llvm::inconvertibleErrorCode());
196   }
197 }
198 
199 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
200                         FunctionInfo *I) {
201   switch (ID) {
202   case FUNCTION_USR:
203     return decodeRecord(R, I->USR, Blob);
204   case FUNCTION_NAME:
205     return decodeRecord(R, I->Name, Blob);
206   case FUNCTION_DEFLOCATION:
207     return decodeRecord(R, I->DefLoc, Blob);
208   case FUNCTION_LOCATION:
209     return decodeRecord(R, I->Loc, Blob);
210   case FUNCTION_ACCESS:
211     return decodeRecord(R, I->Access, Blob);
212   case FUNCTION_IS_METHOD:
213     return decodeRecord(R, I->IsMethod, Blob);
214   default:
215     return llvm::make_error<llvm::StringError>(
216         "Invalid field for FunctionInfo.\n", llvm::inconvertibleErrorCode());
217   }
218 }
219 
220 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
221                         TypeInfo *I) {
222   return llvm::Error::success();
223 }
224 
225 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
226                         FieldTypeInfo *I) {
227   switch (ID) {
228   case FIELD_TYPE_NAME:
229     return decodeRecord(R, I->Name, Blob);
230   default:
231     return llvm::make_error<llvm::StringError>("Invalid field for TypeInfo.\n",
232                                                llvm::inconvertibleErrorCode());
233   }
234 }
235 
236 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
237                         MemberTypeInfo *I) {
238   switch (ID) {
239   case MEMBER_TYPE_NAME:
240     return decodeRecord(R, I->Name, Blob);
241   case MEMBER_TYPE_ACCESS:
242     return decodeRecord(R, I->Access, Blob);
243   default:
244     return llvm::make_error<llvm::StringError>(
245         "Invalid field for MemberTypeInfo.\n", llvm::inconvertibleErrorCode());
246   }
247 }
248 
249 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
250                         CommentInfo *I) {
251   switch (ID) {
252   case COMMENT_KIND:
253     return decodeRecord(R, I->Kind, Blob);
254   case COMMENT_TEXT:
255     return decodeRecord(R, I->Text, Blob);
256   case COMMENT_NAME:
257     return decodeRecord(R, I->Name, Blob);
258   case COMMENT_DIRECTION:
259     return decodeRecord(R, I->Direction, Blob);
260   case COMMENT_PARAMNAME:
261     return decodeRecord(R, I->ParamName, Blob);
262   case COMMENT_CLOSENAME:
263     return decodeRecord(R, I->CloseName, Blob);
264   case COMMENT_ATTRKEY:
265     return decodeRecord(R, I->AttrKeys, Blob);
266   case COMMENT_ATTRVAL:
267     return decodeRecord(R, I->AttrValues, Blob);
268   case COMMENT_ARG:
269     return decodeRecord(R, I->Args, Blob);
270   case COMMENT_SELFCLOSING:
271     return decodeRecord(R, I->SelfClosing, Blob);
272   case COMMENT_EXPLICIT:
273     return decodeRecord(R, I->Explicit, Blob);
274   default:
275     return llvm::make_error<llvm::StringError>(
276         "Invalid field for CommentInfo.\n", llvm::inconvertibleErrorCode());
277   }
278 }
279 
280 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
281                         Reference *I, FieldId &F) {
282   switch (ID) {
283   case REFERENCE_USR:
284     return decodeRecord(R, I->USR, Blob);
285   case REFERENCE_NAME:
286     return decodeRecord(R, I->Name, Blob);
287   case REFERENCE_TYPE:
288     return decodeRecord(R, I->RefType, Blob);
289   case REFERENCE_FIELD:
290     return decodeRecord(R, F, Blob);
291   default:
292     return llvm::make_error<llvm::StringError>("Invalid field for Reference.\n",
293                                                llvm::inconvertibleErrorCode());
294   }
295 }
296 
297 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
298   return llvm::make_error<llvm::StringError>(
299       "Invalid type cannot contain CommentInfo.\n",
300       llvm::inconvertibleErrorCode());
301 }
302 
303 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
304   I->Description.emplace_back();
305   return &I->Description.back();
306 }
307 
308 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {
309   I->Description.emplace_back();
310   return &I->Description.back();
311 }
312 
313 template <> llvm::Expected<CommentInfo *> getCommentInfo(RecordInfo *I) {
314   I->Description.emplace_back();
315   return &I->Description.back();
316 }
317 
318 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumInfo *I) {
319   I->Description.emplace_back();
320   return &I->Description.back();
321 }
322 
323 template <> llvm::Expected<CommentInfo *> getCommentInfo(CommentInfo *I) {
324   I->Children.emplace_back(llvm::make_unique<CommentInfo>());
325   return I->Children.back().get();
326 }
327 
328 template <>
329 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
330   return getCommentInfo(I.get());
331 }
332 
333 template <typename T, typename TTypeInfo>
334 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
335   return llvm::make_error<llvm::StringError>(
336       "Invalid type cannot contain TypeInfo.\n",
337       llvm::inconvertibleErrorCode());
338 }
339 
340 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
341   I->Members.emplace_back(std::move(T));
342   return llvm::Error::success();
343 }
344 
345 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
346   I->ReturnType = std::move(T);
347   return llvm::Error::success();
348 }
349 
350 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
351   I->Params.emplace_back(std::move(T));
352   return llvm::Error::success();
353 }
354 
355 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
356   return llvm::make_error<llvm::StringError>(
357       "Invalid type cannot contain Reference\n",
358       llvm::inconvertibleErrorCode());
359 }
360 
361 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
362   switch (F) {
363   case FieldId::F_type:
364     I->Type = std::move(R);
365     return llvm::Error::success();
366   default:
367     return llvm::make_error<llvm::StringError>(
368         "Invalid type cannot contain Reference.\n",
369         llvm::inconvertibleErrorCode());
370   }
371 }
372 
373 template <>
374 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
375   switch (F) {
376   case FieldId::F_type:
377     I->Type = std::move(R);
378     return llvm::Error::success();
379   default:
380     return llvm::make_error<llvm::StringError>(
381         "Invalid type cannot contain Reference.\n",
382         llvm::inconvertibleErrorCode());
383   }
384 }
385 
386 template <>
387 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
388   switch (F) {
389   case FieldId::F_type:
390     I->Type = std::move(R);
391     return llvm::Error::success();
392   default:
393     return llvm::make_error<llvm::StringError>(
394         "Invalid type cannot contain Reference.\n",
395         llvm::inconvertibleErrorCode());
396   }
397 }
398 
399 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
400   switch (F) {
401   case FieldId::F_namespace:
402     I->Namespace.emplace_back(std::move(R));
403     return llvm::Error::success();
404   default:
405     return llvm::make_error<llvm::StringError>(
406         "Invalid type cannot contain Reference.\n",
407         llvm::inconvertibleErrorCode());
408   }
409 }
410 
411 template <>
412 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
413   switch (F) {
414   case FieldId::F_namespace:
415     I->Namespace.emplace_back(std::move(R));
416     return llvm::Error::success();
417   case FieldId::F_child_namespace:
418     I->ChildNamespaces.emplace_back(std::move(R));
419     return llvm::Error::success();
420   case FieldId::F_child_record:
421     I->ChildRecords.emplace_back(std::move(R));
422     return llvm::Error::success();
423   default:
424     return llvm::make_error<llvm::StringError>(
425         "Invalid type cannot contain Reference.\n",
426         llvm::inconvertibleErrorCode());
427   }
428 }
429 
430 template <>
431 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
432   switch (F) {
433   case FieldId::F_namespace:
434     I->Namespace.emplace_back(std::move(R));
435     return llvm::Error::success();
436   case FieldId::F_parent:
437     I->Parent = std::move(R);
438     return llvm::Error::success();
439   default:
440     return llvm::make_error<llvm::StringError>(
441         "Invalid type cannot contain Reference.\n",
442         llvm::inconvertibleErrorCode());
443   }
444 }
445 
446 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
447   switch (F) {
448   case FieldId::F_namespace:
449     I->Namespace.emplace_back(std::move(R));
450     return llvm::Error::success();
451   case FieldId::F_parent:
452     I->Parents.emplace_back(std::move(R));
453     return llvm::Error::success();
454   case FieldId::F_vparent:
455     I->VirtualParents.emplace_back(std::move(R));
456     return llvm::Error::success();
457   case FieldId::F_child_record:
458     I->ChildRecords.emplace_back(std::move(R));
459     return llvm::Error::success();
460   default:
461     return llvm::make_error<llvm::StringError>(
462         "Invalid type cannot contain Reference.\n",
463         llvm::inconvertibleErrorCode());
464   }
465 }
466 
467 template <typename T, typename ChildInfoType>
468 void addChild(T I, ChildInfoType &&R) {
469   llvm::errs() << "Invalid child type for info.\n";
470   exit(1);
471 }
472 
473 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
474   I->ChildFunctions.emplace_back(std::move(R));
475 }
476 
477 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
478   I->ChildEnums.emplace_back(std::move(R));
479 }
480 
481 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
482   I->ChildFunctions.emplace_back(std::move(R));
483 }
484 
485 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
486   I->ChildEnums.emplace_back(std::move(R));
487 }
488 
489 // Read records from bitcode into a given info.
490 template <typename T>
491 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
492   Record R;
493   llvm::StringRef Blob;
494   unsigned RecID = Stream.readRecord(ID, R, &Blob);
495   return parseRecord(R, RecID, Blob, I);
496 }
497 
498 template <>
499 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
500   Record R;
501   llvm::StringRef Blob;
502   unsigned RecID = Stream.readRecord(ID, R, &Blob);
503   return parseRecord(R, RecID, Blob, I, CurrentReferenceField);
504 }
505 
506 // Read a block of records into a single info.
507 template <typename T>
508 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
509   if (Stream.EnterSubBlock(ID))
510     return llvm::make_error<llvm::StringError>("Unable to enter subblock.\n",
511                                                llvm::inconvertibleErrorCode());
512 
513   while (true) {
514     unsigned BlockOrCode = 0;
515     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
516 
517     switch (Res) {
518     case Cursor::BadBlock:
519       return llvm::make_error<llvm::StringError>(
520           "Bad block found.\n", llvm::inconvertibleErrorCode());
521     case Cursor::BlockEnd:
522       return llvm::Error::success();
523     case Cursor::BlockBegin:
524       if (auto Err = readSubBlock(BlockOrCode, I)) {
525         if (!Stream.SkipBlock())
526           continue;
527         return Err;
528       }
529       continue;
530     case Cursor::Record:
531       break;
532     }
533     if (auto Err = readRecord(BlockOrCode, I))
534       return Err;
535   }
536 }
537 
538 template <typename T>
539 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
540   switch (ID) {
541   // Blocks can only have Comment, Reference, TypeInfo, FunctionInfo, or
542   // EnumInfo subblocks
543   case BI_COMMENT_BLOCK_ID: {
544     auto Comment = getCommentInfo(I);
545     if (!Comment)
546       return Comment.takeError();
547     if (auto Err = readBlock(ID, Comment.get()))
548       return Err;
549     return llvm::Error::success();
550   }
551   case BI_TYPE_BLOCK_ID: {
552     TypeInfo TI;
553     if (auto Err = readBlock(ID, &TI))
554       return Err;
555     if (auto Err = addTypeInfo(I, std::move(TI)))
556       return Err;
557     return llvm::Error::success();
558   }
559   case BI_FIELD_TYPE_BLOCK_ID: {
560     FieldTypeInfo TI;
561     if (auto Err = readBlock(ID, &TI))
562       return Err;
563     if (auto Err = addTypeInfo(I, std::move(TI)))
564       return Err;
565     return llvm::Error::success();
566   }
567   case BI_MEMBER_TYPE_BLOCK_ID: {
568     MemberTypeInfo TI;
569     if (auto Err = readBlock(ID, &TI))
570       return Err;
571     if (auto Err = addTypeInfo(I, std::move(TI)))
572       return Err;
573     return llvm::Error::success();
574   }
575   case BI_REFERENCE_BLOCK_ID: {
576     Reference R;
577     if (auto Err = readBlock(ID, &R))
578       return Err;
579     if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
580       return Err;
581     return llvm::Error::success();
582   }
583   case BI_FUNCTION_BLOCK_ID: {
584     FunctionInfo F;
585     if (auto Err = readBlock(ID, &F))
586       return Err;
587     addChild(I, std::move(F));
588     return llvm::Error::success();
589   }
590   case BI_ENUM_BLOCK_ID: {
591     EnumInfo E;
592     if (auto Err = readBlock(ID, &E))
593       return Err;
594     addChild(I, std::move(E));
595     return llvm::Error::success();
596   }
597   default:
598     return llvm::make_error<llvm::StringError>("Invalid subblock type.\n",
599                                                llvm::inconvertibleErrorCode());
600   }
601 }
602 
603 ClangDocBitcodeReader::Cursor
604 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
605   BlockOrRecordID = 0;
606 
607   while (!Stream.AtEndOfStream()) {
608     unsigned Code = Stream.ReadCode();
609 
610     switch ((llvm::bitc::FixedAbbrevIDs)Code) {
611     case llvm::bitc::ENTER_SUBBLOCK:
612       BlockOrRecordID = Stream.ReadSubBlockID();
613       return Cursor::BlockBegin;
614     case llvm::bitc::END_BLOCK:
615       if (Stream.ReadBlockEnd())
616         return Cursor::BadBlock;
617       return Cursor::BlockEnd;
618     case llvm::bitc::DEFINE_ABBREV:
619       Stream.ReadAbbrevRecord();
620       continue;
621     case llvm::bitc::UNABBREV_RECORD:
622       return Cursor::BadBlock;
623     default:
624       BlockOrRecordID = Code;
625       return Cursor::Record;
626     }
627   }
628   llvm_unreachable("Premature stream end.");
629 }
630 
631 llvm::Error ClangDocBitcodeReader::validateStream() {
632   if (Stream.AtEndOfStream())
633     return llvm::make_error<llvm::StringError>("Premature end of stream.\n",
634                                                llvm::inconvertibleErrorCode());
635 
636   // Sniff for the signature.
637   if (Stream.Read(8) != BitCodeConstants::Signature[0] ||
638       Stream.Read(8) != BitCodeConstants::Signature[1] ||
639       Stream.Read(8) != BitCodeConstants::Signature[2] ||
640       Stream.Read(8) != BitCodeConstants::Signature[3])
641     return llvm::make_error<llvm::StringError>("Invalid bitcode signature.\n",
642                                                llvm::inconvertibleErrorCode());
643   return llvm::Error::success();
644 }
645 
646 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
647   BlockInfo = Stream.ReadBlockInfoBlock();
648   if (!BlockInfo)
649     return llvm::make_error<llvm::StringError>(
650         "Unable to parse BlockInfoBlock.\n", llvm::inconvertibleErrorCode());
651   Stream.setBlockInfo(&*BlockInfo);
652   return llvm::Error::success();
653 }
654 
655 template <typename T>
656 llvm::Expected<std::unique_ptr<Info>>
657 ClangDocBitcodeReader::createInfo(unsigned ID) {
658   std::unique_ptr<Info> I = llvm::make_unique<T>();
659   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
660     return std::move(Err);
661   return std::unique_ptr<Info>{std::move(I)};;
662 }
663 
664 llvm::Expected<std::unique_ptr<Info>>
665 ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
666   switch (ID) {
667   case BI_NAMESPACE_BLOCK_ID:
668     return createInfo<NamespaceInfo>(ID);
669   case BI_RECORD_BLOCK_ID:
670     return createInfo<RecordInfo>(ID);
671   case BI_ENUM_BLOCK_ID:
672     return createInfo<EnumInfo>(ID);
673   case BI_FUNCTION_BLOCK_ID:
674     return createInfo<FunctionInfo>(ID);
675   default:
676     return llvm::make_error<llvm::StringError>("Cannot create info.\n",
677                                                llvm::inconvertibleErrorCode());
678   }
679 }
680 
681 // Entry point
682 llvm::Expected<std::vector<std::unique_ptr<Info>>>
683 ClangDocBitcodeReader::readBitcode() {
684   std::vector<std::unique_ptr<Info>> Infos;
685   if (auto Err = validateStream())
686     return std::move(Err);
687 
688   // Read the top level blocks.
689   while (!Stream.AtEndOfStream()) {
690     unsigned Code = Stream.ReadCode();
691     if (Code != llvm::bitc::ENTER_SUBBLOCK)
692       return llvm::make_error<llvm::StringError>(
693           "No blocks in input.\n", llvm::inconvertibleErrorCode());
694     unsigned ID = Stream.ReadSubBlockID();
695     switch (ID) {
696     // NamedType and Comment blocks should not appear at the top level
697     case BI_TYPE_BLOCK_ID:
698     case BI_FIELD_TYPE_BLOCK_ID:
699     case BI_MEMBER_TYPE_BLOCK_ID:
700     case BI_COMMENT_BLOCK_ID:
701     case BI_REFERENCE_BLOCK_ID:
702       return llvm::make_error<llvm::StringError>(
703           "Invalid top level block.\n", llvm::inconvertibleErrorCode());
704     case BI_NAMESPACE_BLOCK_ID:
705     case BI_RECORD_BLOCK_ID:
706     case BI_ENUM_BLOCK_ID:
707     case BI_FUNCTION_BLOCK_ID: {
708       auto InfoOrErr = readBlockToInfo(ID);
709       if (!InfoOrErr)
710         return InfoOrErr.takeError();
711       Infos.emplace_back(std::move(InfoOrErr.get()));
712       continue;
713     }
714     case BI_VERSION_BLOCK_ID:
715       if (auto Err = readBlock(ID, VersionNumber))
716         return std::move(Err);
717       continue;
718     case llvm::bitc::BLOCKINFO_BLOCK_ID:
719       if (auto Err = readBlockInfoBlock())
720         return std::move(Err);
721       continue;
722     default:
723       if (!Stream.SkipBlock())
724         continue;
725     }
726   }
727   return std::move(Infos);
728 }
729 
730 } // namespace doc
731 } // namespace clang
732