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