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