xref: /llvm-project/clang-tools-extra/clang-doc/BitcodeReader.cpp (revision e191086bfcb72a98a9e299fd30dd3f69c5de5b64) 
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   case FIELD_DEFAULT_VALUE:
263     return decodeRecord(R, I->DefaultValue, Blob);
264   default:
265     return llvm::createStringError(llvm::inconvertibleErrorCode(),
266                                    "invalid field for TypeInfo");
267   }
268 }
269 
270 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
271                         MemberTypeInfo *I) {
272   switch (ID) {
273   case MEMBER_TYPE_NAME:
274     return decodeRecord(R, I->Name, Blob);
275   case MEMBER_TYPE_ACCESS:
276     return decodeRecord(R, I->Access, Blob);
277   default:
278     return llvm::createStringError(llvm::inconvertibleErrorCode(),
279                                    "invalid field for MemberTypeInfo");
280   }
281 }
282 
283 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
284                         CommentInfo *I) {
285   switch (ID) {
286   case COMMENT_KIND:
287     return decodeRecord(R, I->Kind, Blob);
288   case COMMENT_TEXT:
289     return decodeRecord(R, I->Text, Blob);
290   case COMMENT_NAME:
291     return decodeRecord(R, I->Name, Blob);
292   case COMMENT_DIRECTION:
293     return decodeRecord(R, I->Direction, Blob);
294   case COMMENT_PARAMNAME:
295     return decodeRecord(R, I->ParamName, Blob);
296   case COMMENT_CLOSENAME:
297     return decodeRecord(R, I->CloseName, Blob);
298   case COMMENT_ATTRKEY:
299     return decodeRecord(R, I->AttrKeys, Blob);
300   case COMMENT_ATTRVAL:
301     return decodeRecord(R, I->AttrValues, Blob);
302   case COMMENT_ARG:
303     return decodeRecord(R, I->Args, Blob);
304   case COMMENT_SELFCLOSING:
305     return decodeRecord(R, I->SelfClosing, Blob);
306   case COMMENT_EXPLICIT:
307     return decodeRecord(R, I->Explicit, Blob);
308   default:
309     return llvm::createStringError(llvm::inconvertibleErrorCode(),
310                                    "invalid field for CommentInfo");
311   }
312 }
313 
314 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
315                         Reference *I, FieldId &F) {
316   switch (ID) {
317   case REFERENCE_USR:
318     return decodeRecord(R, I->USR, Blob);
319   case REFERENCE_NAME:
320     return decodeRecord(R, I->Name, Blob);
321   case REFERENCE_TYPE:
322     return decodeRecord(R, I->RefType, Blob);
323   case REFERENCE_PATH:
324     return decodeRecord(R, I->Path, Blob);
325   case REFERENCE_IS_IN_GLOBAL_NAMESPACE:
326     return decodeRecord(R, I->IsInGlobalNamespace, Blob);
327   case REFERENCE_FIELD:
328     return decodeRecord(R, F, Blob);
329   default:
330     return llvm::createStringError(llvm::inconvertibleErrorCode(),
331                                    "invalid field for Reference");
332   }
333 }
334 
335 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
336   return llvm::createStringError(llvm::inconvertibleErrorCode(),
337                                  "invalid type cannot contain CommentInfo");
338 }
339 
340 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
341   I->Description.emplace_back();
342   return &I->Description.back();
343 }
344 
345 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {
346   I->Description.emplace_back();
347   return &I->Description.back();
348 }
349 
350 template <> llvm::Expected<CommentInfo *> getCommentInfo(RecordInfo *I) {
351   I->Description.emplace_back();
352   return &I->Description.back();
353 }
354 
355 template <> llvm::Expected<CommentInfo *> getCommentInfo(MemberTypeInfo *I) {
356   I->Description.emplace_back();
357   return &I->Description.back();
358 }
359 
360 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumInfo *I) {
361   I->Description.emplace_back();
362   return &I->Description.back();
363 }
364 
365 template <> llvm::Expected<CommentInfo *> getCommentInfo(CommentInfo *I) {
366   I->Children.emplace_back(std::make_unique<CommentInfo>());
367   return I->Children.back().get();
368 }
369 
370 template <>
371 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
372   return getCommentInfo(I.get());
373 }
374 
375 template <typename T, typename TTypeInfo>
376 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
377   return llvm::createStringError(llvm::inconvertibleErrorCode(),
378                                  "invalid type cannot contain TypeInfo");
379 }
380 
381 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
382   I->Members.emplace_back(std::move(T));
383   return llvm::Error::success();
384 }
385 
386 template <> llvm::Error addTypeInfo(BaseRecordInfo *I, MemberTypeInfo &&T) {
387   I->Members.emplace_back(std::move(T));
388   return llvm::Error::success();
389 }
390 
391 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
392   I->ReturnType = std::move(T);
393   return llvm::Error::success();
394 }
395 
396 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
397   I->Params.emplace_back(std::move(T));
398   return llvm::Error::success();
399 }
400 
401 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
402   return llvm::createStringError(llvm::inconvertibleErrorCode(),
403                                  "invalid type cannot contain Reference");
404 }
405 
406 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
407   switch (F) {
408   case FieldId::F_type:
409     I->Type = std::move(R);
410     return llvm::Error::success();
411   default:
412     return llvm::createStringError(llvm::inconvertibleErrorCode(),
413                                    "invalid type cannot contain Reference");
414   }
415 }
416 
417 template <>
418 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
419   switch (F) {
420   case FieldId::F_type:
421     I->Type = std::move(R);
422     return llvm::Error::success();
423   default:
424     return llvm::createStringError(llvm::inconvertibleErrorCode(),
425                                    "invalid type cannot contain Reference");
426   }
427 }
428 
429 template <>
430 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
431   switch (F) {
432   case FieldId::F_type:
433     I->Type = std::move(R);
434     return llvm::Error::success();
435   default:
436     return llvm::createStringError(llvm::inconvertibleErrorCode(),
437                                    "invalid type cannot contain Reference");
438   }
439 }
440 
441 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
442   switch (F) {
443   case FieldId::F_namespace:
444     I->Namespace.emplace_back(std::move(R));
445     return llvm::Error::success();
446   default:
447     return llvm::createStringError(llvm::inconvertibleErrorCode(),
448                                    "invalid type cannot contain Reference");
449   }
450 }
451 
452 template <>
453 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
454   switch (F) {
455   case FieldId::F_namespace:
456     I->Namespace.emplace_back(std::move(R));
457     return llvm::Error::success();
458   case FieldId::F_child_namespace:
459     I->ChildNamespaces.emplace_back(std::move(R));
460     return llvm::Error::success();
461   case FieldId::F_child_record:
462     I->ChildRecords.emplace_back(std::move(R));
463     return llvm::Error::success();
464   default:
465     return llvm::createStringError(llvm::inconvertibleErrorCode(),
466                                    "invalid type cannot contain Reference");
467   }
468 }
469 
470 template <>
471 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
472   switch (F) {
473   case FieldId::F_namespace:
474     I->Namespace.emplace_back(std::move(R));
475     return llvm::Error::success();
476   case FieldId::F_parent:
477     I->Parent = std::move(R);
478     return llvm::Error::success();
479   default:
480     return llvm::createStringError(llvm::inconvertibleErrorCode(),
481                                    "invalid type cannot contain Reference");
482   }
483 }
484 
485 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
486   switch (F) {
487   case FieldId::F_namespace:
488     I->Namespace.emplace_back(std::move(R));
489     return llvm::Error::success();
490   case FieldId::F_parent:
491     I->Parents.emplace_back(std::move(R));
492     return llvm::Error::success();
493   case FieldId::F_vparent:
494     I->VirtualParents.emplace_back(std::move(R));
495     return llvm::Error::success();
496   case FieldId::F_child_record:
497     I->ChildRecords.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 <typename T, typename ChildInfoType>
506 void addChild(T I, ChildInfoType &&R) {
507   llvm::errs() << "invalid child type for info";
508   exit(1);
509 }
510 
511 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
512   I->ChildFunctions.emplace_back(std::move(R));
513 }
514 
515 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
516   I->ChildEnums.emplace_back(std::move(R));
517 }
518 
519 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
520   I->ChildFunctions.emplace_back(std::move(R));
521 }
522 
523 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
524   I->ChildEnums.emplace_back(std::move(R));
525 }
526 
527 template <> void addChild(RecordInfo *I, BaseRecordInfo &&R) {
528   I->Bases.emplace_back(std::move(R));
529 }
530 
531 template <> void addChild(BaseRecordInfo *I, FunctionInfo &&R) {
532   I->ChildFunctions.emplace_back(std::move(R));
533 }
534 
535 // Read records from bitcode into a given info.
536 template <typename T>
537 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
538   Record R;
539   llvm::StringRef Blob;
540   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
541   if (!MaybeRecID)
542     return MaybeRecID.takeError();
543   return parseRecord(R, MaybeRecID.get(), Blob, I);
544 }
545 
546 template <>
547 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
548   Record R;
549   llvm::StringRef Blob;
550   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
551   if (!MaybeRecID)
552     return MaybeRecID.takeError();
553   return parseRecord(R, MaybeRecID.get(), Blob, I, CurrentReferenceField);
554 }
555 
556 // Read a block of records into a single info.
557 template <typename T>
558 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
559   if (llvm::Error Err = Stream.EnterSubBlock(ID))
560     return Err;
561 
562   while (true) {
563     unsigned BlockOrCode = 0;
564     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
565 
566     switch (Res) {
567     case Cursor::BadBlock:
568       return llvm::createStringError(llvm::inconvertibleErrorCode(),
569                                      "bad block found");
570     case Cursor::BlockEnd:
571       return llvm::Error::success();
572     case Cursor::BlockBegin:
573       if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
574         if (llvm::Error Skipped = Stream.SkipBlock())
575           return joinErrors(std::move(Err), std::move(Skipped));
576         return Err;
577       }
578       continue;
579     case Cursor::Record:
580       break;
581     }
582     if (auto Err = readRecord(BlockOrCode, I))
583       return Err;
584   }
585 }
586 
587 template <typename T>
588 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
589   switch (ID) {
590   // Blocks can only have Comment, Reference, TypeInfo, FunctionInfo, or
591   // EnumInfo subblocks
592   case BI_COMMENT_BLOCK_ID: {
593     auto Comment = getCommentInfo(I);
594     if (!Comment)
595       return Comment.takeError();
596     if (auto Err = readBlock(ID, Comment.get()))
597       return Err;
598     return llvm::Error::success();
599   }
600   case BI_TYPE_BLOCK_ID: {
601     TypeInfo TI;
602     if (auto Err = readBlock(ID, &TI))
603       return Err;
604     if (auto Err = addTypeInfo(I, std::move(TI)))
605       return Err;
606     return llvm::Error::success();
607   }
608   case BI_FIELD_TYPE_BLOCK_ID: {
609     FieldTypeInfo TI;
610     if (auto Err = readBlock(ID, &TI))
611       return Err;
612     if (auto Err = addTypeInfo(I, std::move(TI)))
613       return Err;
614     return llvm::Error::success();
615   }
616   case BI_MEMBER_TYPE_BLOCK_ID: {
617     MemberTypeInfo TI;
618     if (auto Err = readBlock(ID, &TI))
619       return Err;
620     if (auto Err = addTypeInfo(I, std::move(TI)))
621       return Err;
622     return llvm::Error::success();
623   }
624   case BI_REFERENCE_BLOCK_ID: {
625     Reference R;
626     if (auto Err = readBlock(ID, &R))
627       return Err;
628     if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
629       return Err;
630     return llvm::Error::success();
631   }
632   case BI_FUNCTION_BLOCK_ID: {
633     FunctionInfo F;
634     if (auto Err = readBlock(ID, &F))
635       return Err;
636     addChild(I, std::move(F));
637     return llvm::Error::success();
638   }
639   case BI_BASE_RECORD_BLOCK_ID: {
640     BaseRecordInfo BR;
641     if (auto Err = readBlock(ID, &BR))
642       return Err;
643     addChild(I, std::move(BR));
644     return llvm::Error::success();
645   }
646   case BI_ENUM_BLOCK_ID: {
647     EnumInfo E;
648     if (auto Err = readBlock(ID, &E))
649       return Err;
650     addChild(I, std::move(E));
651     return llvm::Error::success();
652   }
653   default:
654     return llvm::createStringError(llvm::inconvertibleErrorCode(),
655                                    "invalid subblock type");
656   }
657 }
658 
659 ClangDocBitcodeReader::Cursor
660 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
661   BlockOrRecordID = 0;
662 
663   while (!Stream.AtEndOfStream()) {
664     Expected<unsigned> MaybeCode = Stream.ReadCode();
665     if (!MaybeCode) {
666       // FIXME this drops the error on the floor.
667       consumeError(MaybeCode.takeError());
668       return Cursor::BadBlock;
669     }
670 
671     unsigned Code = MaybeCode.get();
672     if (Code >= static_cast<unsigned>(llvm::bitc::FIRST_APPLICATION_ABBREV)) {
673       BlockOrRecordID = Code;
674       return Cursor::Record;
675     }
676     switch (static_cast<llvm::bitc::FixedAbbrevIDs>(Code)) {
677     case llvm::bitc::ENTER_SUBBLOCK:
678       if (Expected<unsigned> MaybeID = Stream.ReadSubBlockID())
679         BlockOrRecordID = MaybeID.get();
680       else {
681         // FIXME this drops the error on the floor.
682         consumeError(MaybeID.takeError());
683       }
684       return Cursor::BlockBegin;
685     case llvm::bitc::END_BLOCK:
686       if (Stream.ReadBlockEnd())
687         return Cursor::BadBlock;
688       return Cursor::BlockEnd;
689     case llvm::bitc::DEFINE_ABBREV:
690       if (llvm::Error Err = Stream.ReadAbbrevRecord()) {
691         // FIXME this drops the error on the floor.
692         consumeError(std::move(Err));
693       }
694       continue;
695     case llvm::bitc::UNABBREV_RECORD:
696       return Cursor::BadBlock;
697     case llvm::bitc::FIRST_APPLICATION_ABBREV:
698       llvm_unreachable("Unexpected abbrev id.");
699     }
700   }
701   llvm_unreachable("Premature stream end.");
702 }
703 
704 llvm::Error ClangDocBitcodeReader::validateStream() {
705   if (Stream.AtEndOfStream())
706     return llvm::createStringError(llvm::inconvertibleErrorCode(),
707                                    "premature end of stream");
708 
709   // Sniff for the signature.
710   for (int Idx = 0; Idx != 4; ++Idx) {
711     Expected<llvm::SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(8);
712     if (!MaybeRead)
713       return MaybeRead.takeError();
714     else if (MaybeRead.get() != BitCodeConstants::Signature[Idx])
715       return llvm::createStringError(llvm::inconvertibleErrorCode(),
716                                      "invalid bitcode signature");
717   }
718   return llvm::Error::success();
719 }
720 
721 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
722   Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
723       Stream.ReadBlockInfoBlock();
724   if (!MaybeBlockInfo)
725     return MaybeBlockInfo.takeError();
726   else
727     BlockInfo = MaybeBlockInfo.get();
728   if (!BlockInfo)
729     return llvm::createStringError(llvm::inconvertibleErrorCode(),
730                                    "unable to parse BlockInfoBlock");
731   Stream.setBlockInfo(&*BlockInfo);
732   return llvm::Error::success();
733 }
734 
735 template <typename T>
736 llvm::Expected<std::unique_ptr<Info>>
737 ClangDocBitcodeReader::createInfo(unsigned ID) {
738   std::unique_ptr<Info> I = std::make_unique<T>();
739   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
740     return std::move(Err);
741   return std::unique_ptr<Info>{std::move(I)};
742 }
743 
744 llvm::Expected<std::unique_ptr<Info>>
745 ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
746   switch (ID) {
747   case BI_NAMESPACE_BLOCK_ID:
748     return createInfo<NamespaceInfo>(ID);
749   case BI_RECORD_BLOCK_ID:
750     return createInfo<RecordInfo>(ID);
751   case BI_ENUM_BLOCK_ID:
752     return createInfo<EnumInfo>(ID);
753   case BI_FUNCTION_BLOCK_ID:
754     return createInfo<FunctionInfo>(ID);
755   default:
756     return llvm::createStringError(llvm::inconvertibleErrorCode(),
757                                    "cannot create info");
758   }
759 }
760 
761 // Entry point
762 llvm::Expected<std::vector<std::unique_ptr<Info>>>
763 ClangDocBitcodeReader::readBitcode() {
764   std::vector<std::unique_ptr<Info>> Infos;
765   if (auto Err = validateStream())
766     return std::move(Err);
767 
768   // Read the top level blocks.
769   while (!Stream.AtEndOfStream()) {
770     Expected<unsigned> MaybeCode = Stream.ReadCode();
771     if (!MaybeCode)
772       return MaybeCode.takeError();
773     if (MaybeCode.get() != llvm::bitc::ENTER_SUBBLOCK)
774       return llvm::createStringError(llvm::inconvertibleErrorCode(),
775                                      "no blocks in input");
776     Expected<unsigned> MaybeID = Stream.ReadSubBlockID();
777     if (!MaybeID)
778       return MaybeID.takeError();
779     unsigned ID = MaybeID.get();
780     switch (ID) {
781     // NamedType and Comment blocks should not appear at the top level
782     case BI_TYPE_BLOCK_ID:
783     case BI_FIELD_TYPE_BLOCK_ID:
784     case BI_MEMBER_TYPE_BLOCK_ID:
785     case BI_COMMENT_BLOCK_ID:
786     case BI_REFERENCE_BLOCK_ID:
787       return llvm::createStringError(llvm::inconvertibleErrorCode(),
788                                      "invalid top level block");
789     case BI_NAMESPACE_BLOCK_ID:
790     case BI_RECORD_BLOCK_ID:
791     case BI_ENUM_BLOCK_ID:
792     case BI_FUNCTION_BLOCK_ID: {
793       auto InfoOrErr = readBlockToInfo(ID);
794       if (!InfoOrErr)
795         return InfoOrErr.takeError();
796       Infos.emplace_back(std::move(InfoOrErr.get()));
797       continue;
798     }
799     case BI_VERSION_BLOCK_ID:
800       if (auto Err = readBlock(ID, VersionNumber))
801         return std::move(Err);
802       continue;
803     case llvm::bitc::BLOCKINFO_BLOCK_ID:
804       if (auto Err = readBlockInfoBlock())
805         return std::move(Err);
806       continue;
807     default:
808       if (llvm::Error Err = Stream.SkipBlock()) {
809         // FIXME this drops the error on the floor.
810         consumeError(std::move(Err));
811       }
812       continue;
813     }
814   }
815   return std::move(Infos);
816 }
817 
818 } // namespace doc
819 } // namespace clang
820