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