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   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
495   if (!MaybeRecID)
496     return MaybeRecID.takeError();
497   return parseRecord(R, MaybeRecID.get(), Blob, I);
498 }
499 
500 template <>
501 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
502   Record R;
503   llvm::StringRef Blob;
504   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
505   if (!MaybeRecID)
506     return MaybeRecID.takeError();
507   return parseRecord(R, MaybeRecID.get(), Blob, I, CurrentReferenceField);
508 }
509 
510 // Read a block of records into a single info.
511 template <typename T>
512 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
513   if (llvm::Error Err = Stream.EnterSubBlock(ID))
514     return Err;
515 
516   while (true) {
517     unsigned BlockOrCode = 0;
518     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
519 
520     switch (Res) {
521     case Cursor::BadBlock:
522       return llvm::make_error<llvm::StringError>(
523           "Bad block found.\n", llvm::inconvertibleErrorCode());
524     case Cursor::BlockEnd:
525       return llvm::Error::success();
526     case Cursor::BlockBegin:
527       if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
528         if (llvm::Error Skipped = Stream.SkipBlock())
529           return joinErrors(std::move(Err), std::move(Skipped));
530         return Err;
531       }
532       continue;
533     case Cursor::Record:
534       break;
535     }
536     if (auto Err = readRecord(BlockOrCode, I))
537       return Err;
538   }
539 }
540 
541 template <typename T>
542 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
543   switch (ID) {
544   // Blocks can only have Comment, Reference, TypeInfo, FunctionInfo, or
545   // EnumInfo subblocks
546   case BI_COMMENT_BLOCK_ID: {
547     auto Comment = getCommentInfo(I);
548     if (!Comment)
549       return Comment.takeError();
550     if (auto Err = readBlock(ID, Comment.get()))
551       return Err;
552     return llvm::Error::success();
553   }
554   case BI_TYPE_BLOCK_ID: {
555     TypeInfo TI;
556     if (auto Err = readBlock(ID, &TI))
557       return Err;
558     if (auto Err = addTypeInfo(I, std::move(TI)))
559       return Err;
560     return llvm::Error::success();
561   }
562   case BI_FIELD_TYPE_BLOCK_ID: {
563     FieldTypeInfo TI;
564     if (auto Err = readBlock(ID, &TI))
565       return Err;
566     if (auto Err = addTypeInfo(I, std::move(TI)))
567       return Err;
568     return llvm::Error::success();
569   }
570   case BI_MEMBER_TYPE_BLOCK_ID: {
571     MemberTypeInfo TI;
572     if (auto Err = readBlock(ID, &TI))
573       return Err;
574     if (auto Err = addTypeInfo(I, std::move(TI)))
575       return Err;
576     return llvm::Error::success();
577   }
578   case BI_REFERENCE_BLOCK_ID: {
579     Reference R;
580     if (auto Err = readBlock(ID, &R))
581       return Err;
582     if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
583       return Err;
584     return llvm::Error::success();
585   }
586   case BI_FUNCTION_BLOCK_ID: {
587     FunctionInfo F;
588     if (auto Err = readBlock(ID, &F))
589       return Err;
590     addChild(I, std::move(F));
591     return llvm::Error::success();
592   }
593   case BI_ENUM_BLOCK_ID: {
594     EnumInfo E;
595     if (auto Err = readBlock(ID, &E))
596       return Err;
597     addChild(I, std::move(E));
598     return llvm::Error::success();
599   }
600   default:
601     return llvm::make_error<llvm::StringError>("Invalid subblock type.\n",
602                                                llvm::inconvertibleErrorCode());
603   }
604 }
605 
606 ClangDocBitcodeReader::Cursor
607 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
608   BlockOrRecordID = 0;
609 
610   while (!Stream.AtEndOfStream()) {
611     Expected<unsigned> MaybeCode = Stream.ReadCode();
612     if (!MaybeCode) {
613       // FIXME this drops the error on the floor.
614       consumeError(MaybeCode.takeError());
615       return Cursor::BadBlock;
616     }
617 
618     unsigned Code = MaybeCode.get();
619     if (Code >= static_cast<unsigned>(llvm::bitc::FIRST_APPLICATION_ABBREV)) {
620       BlockOrRecordID = Code;
621       return Cursor::Record;
622     }
623     switch (static_cast<llvm::bitc::FixedAbbrevIDs>(Code)) {
624     case llvm::bitc::ENTER_SUBBLOCK:
625       if (Expected<unsigned> MaybeID = Stream.ReadSubBlockID())
626         BlockOrRecordID = MaybeID.get();
627       else {
628         // FIXME this drops the error on the floor.
629         consumeError(MaybeID.takeError());
630       }
631       return Cursor::BlockBegin;
632     case llvm::bitc::END_BLOCK:
633       if (Stream.ReadBlockEnd())
634         return Cursor::BadBlock;
635       return Cursor::BlockEnd;
636     case llvm::bitc::DEFINE_ABBREV:
637       if (llvm::Error Err = Stream.ReadAbbrevRecord()) {
638         // FIXME this drops the error on the floor.
639         consumeError(std::move(Err));
640       }
641       continue;
642     case llvm::bitc::UNABBREV_RECORD:
643       return Cursor::BadBlock;
644     case llvm::bitc::FIRST_APPLICATION_ABBREV:
645       llvm_unreachable("Unexpected abbrev id.");
646     }
647   }
648   llvm_unreachable("Premature stream end.");
649 }
650 
651 llvm::Error ClangDocBitcodeReader::validateStream() {
652   if (Stream.AtEndOfStream())
653     return llvm::make_error<llvm::StringError>("Premature end of stream.\n",
654                                                llvm::inconvertibleErrorCode());
655 
656   // Sniff for the signature.
657   for (int Idx = 0; Idx != 4; ++Idx) {
658     Expected<llvm::SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(8);
659     if (!MaybeRead)
660       return MaybeRead.takeError();
661     else if (MaybeRead.get() != BitCodeConstants::Signature[Idx])
662       return llvm::make_error<llvm::StringError>(
663           "Invalid bitcode signature.\n", llvm::inconvertibleErrorCode());
664   }
665   return llvm::Error::success();
666 }
667 
668 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
669   Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
670       Stream.ReadBlockInfoBlock();
671   if (!MaybeBlockInfo)
672     return MaybeBlockInfo.takeError();
673   else
674     BlockInfo = MaybeBlockInfo.get();
675   if (!BlockInfo)
676     return llvm::make_error<llvm::StringError>(
677         "Unable to parse BlockInfoBlock.\n", llvm::inconvertibleErrorCode());
678   Stream.setBlockInfo(&*BlockInfo);
679   return llvm::Error::success();
680 }
681 
682 template <typename T>
683 llvm::Expected<std::unique_ptr<Info>>
684 ClangDocBitcodeReader::createInfo(unsigned ID) {
685   std::unique_ptr<Info> I = llvm::make_unique<T>();
686   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
687     return std::move(Err);
688   return std::unique_ptr<Info>{std::move(I)};;
689 }
690 
691 llvm::Expected<std::unique_ptr<Info>>
692 ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
693   switch (ID) {
694   case BI_NAMESPACE_BLOCK_ID:
695     return createInfo<NamespaceInfo>(ID);
696   case BI_RECORD_BLOCK_ID:
697     return createInfo<RecordInfo>(ID);
698   case BI_ENUM_BLOCK_ID:
699     return createInfo<EnumInfo>(ID);
700   case BI_FUNCTION_BLOCK_ID:
701     return createInfo<FunctionInfo>(ID);
702   default:
703     return llvm::make_error<llvm::StringError>("Cannot create info.\n",
704                                                llvm::inconvertibleErrorCode());
705   }
706 }
707 
708 // Entry point
709 llvm::Expected<std::vector<std::unique_ptr<Info>>>
710 ClangDocBitcodeReader::readBitcode() {
711   std::vector<std::unique_ptr<Info>> Infos;
712   if (auto Err = validateStream())
713     return std::move(Err);
714 
715   // Read the top level blocks.
716   while (!Stream.AtEndOfStream()) {
717     Expected<unsigned> MaybeCode = Stream.ReadCode();
718     if (!MaybeCode)
719       return MaybeCode.takeError();
720     if (MaybeCode.get() != llvm::bitc::ENTER_SUBBLOCK)
721       return llvm::make_error<llvm::StringError>(
722           "No blocks in input.\n", llvm::inconvertibleErrorCode());
723     Expected<unsigned> MaybeID = Stream.ReadSubBlockID();
724     if (!MaybeID)
725       return MaybeID.takeError();
726     unsigned ID = MaybeID.get();
727     switch (ID) {
728     // NamedType and Comment blocks should not appear at the top level
729     case BI_TYPE_BLOCK_ID:
730     case BI_FIELD_TYPE_BLOCK_ID:
731     case BI_MEMBER_TYPE_BLOCK_ID:
732     case BI_COMMENT_BLOCK_ID:
733     case BI_REFERENCE_BLOCK_ID:
734       return llvm::make_error<llvm::StringError>(
735           "Invalid top level block.\n", llvm::inconvertibleErrorCode());
736     case BI_NAMESPACE_BLOCK_ID:
737     case BI_RECORD_BLOCK_ID:
738     case BI_ENUM_BLOCK_ID:
739     case BI_FUNCTION_BLOCK_ID: {
740       auto InfoOrErr = readBlockToInfo(ID);
741       if (!InfoOrErr)
742         return InfoOrErr.takeError();
743       Infos.emplace_back(std::move(InfoOrErr.get()));
744       continue;
745     }
746     case BI_VERSION_BLOCK_ID:
747       if (auto Err = readBlock(ID, VersionNumber))
748         return std::move(Err);
749       continue;
750     case llvm::bitc::BLOCKINFO_BLOCK_ID:
751       if (auto Err = readBlockInfoBlock())
752         return std::move(Err);
753       continue;
754     default:
755       if (llvm::Error Err = Stream.SkipBlock()) {
756         // FIXME this drops the error on the floor.
757         consumeError(std::move(Err));
758       }
759       continue;
760     }
761   }
762   return std::move(Infos);
763 }
764 
765 } // namespace doc
766 } // namespace clang
767