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