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