xref: /llvm-project/clang-tools-extra/clang-doc/BitcodeReader.cpp (revision 0f6dbb5f164662c3e6a167a89e7a89f07c60e32b) 
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_QUAL_NAME:
355     return decodeRecord(R, I->QualName, Blob);
356   case REFERENCE_TYPE:
357     return decodeRecord(R, I->RefType, Blob);
358   case REFERENCE_PATH:
359     return decodeRecord(R, I->Path, Blob);
360   case REFERENCE_FIELD:
361     return decodeRecord(R, F, Blob);
362   default:
363     return llvm::createStringError(llvm::inconvertibleErrorCode(),
364                                    "invalid field for Reference");
365   }
366 }
367 
368 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
369                         TemplateInfo *I) {
370   // Currently there are no child records of TemplateInfo (only child blocks).
371   return llvm::createStringError(llvm::inconvertibleErrorCode(),
372                                  "invalid field for TemplateParamInfo");
373 }
374 
375 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
376                         TemplateSpecializationInfo *I) {
377   if (ID == TEMPLATE_SPECIALIZATION_OF)
378     return decodeRecord(R, I->SpecializationOf, Blob);
379   return llvm::createStringError(llvm::inconvertibleErrorCode(),
380                                  "invalid field for TemplateParamInfo");
381 }
382 
383 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
384                         TemplateParamInfo *I) {
385   if (ID == TEMPLATE_PARAM_CONTENTS)
386     return decodeRecord(R, I->Contents, Blob);
387   return llvm::createStringError(llvm::inconvertibleErrorCode(),
388                                  "invalid field for TemplateParamInfo");
389 }
390 
391 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
392   return llvm::createStringError(llvm::inconvertibleErrorCode(),
393                                  "invalid type cannot contain CommentInfo");
394 }
395 
396 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
397   return &I->Description.emplace_back();
398 }
399 
400 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {
401   return &I->Description.emplace_back();
402 }
403 
404 template <> llvm::Expected<CommentInfo *> getCommentInfo(RecordInfo *I) {
405   return &I->Description.emplace_back();
406 }
407 
408 template <> llvm::Expected<CommentInfo *> getCommentInfo(MemberTypeInfo *I) {
409   return &I->Description.emplace_back();
410 }
411 
412 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumInfo *I) {
413   return &I->Description.emplace_back();
414 }
415 
416 template <> llvm::Expected<CommentInfo *> getCommentInfo(TypedefInfo *I) {
417   return &I->Description.emplace_back();
418 }
419 
420 template <> llvm::Expected<CommentInfo *> getCommentInfo(CommentInfo *I) {
421   I->Children.emplace_back(std::make_unique<CommentInfo>());
422   return I->Children.back().get();
423 }
424 
425 template <>
426 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
427   return getCommentInfo(I.get());
428 }
429 
430 // When readSubBlock encounters a TypeInfo sub-block, it calls addTypeInfo on
431 // the parent block to set it. The template specializations define what to do
432 // for each supported parent block.
433 template <typename T, typename TTypeInfo>
434 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
435   return llvm::createStringError(llvm::inconvertibleErrorCode(),
436                                  "invalid type cannot contain TypeInfo");
437 }
438 
439 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
440   I->Members.emplace_back(std::move(T));
441   return llvm::Error::success();
442 }
443 
444 template <> llvm::Error addTypeInfo(BaseRecordInfo *I, MemberTypeInfo &&T) {
445   I->Members.emplace_back(std::move(T));
446   return llvm::Error::success();
447 }
448 
449 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
450   I->ReturnType = std::move(T);
451   return llvm::Error::success();
452 }
453 
454 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
455   I->Params.emplace_back(std::move(T));
456   return llvm::Error::success();
457 }
458 
459 template <> llvm::Error addTypeInfo(EnumInfo *I, TypeInfo &&T) {
460   I->BaseType = std::move(T);
461   return llvm::Error::success();
462 }
463 
464 template <> llvm::Error addTypeInfo(TypedefInfo *I, TypeInfo &&T) {
465   I->Underlying = std::move(T);
466   return llvm::Error::success();
467 }
468 
469 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
470   return llvm::createStringError(llvm::inconvertibleErrorCode(),
471                                  "invalid type cannot contain Reference");
472 }
473 
474 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
475   switch (F) {
476   case FieldId::F_type:
477     I->Type = 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 <>
486 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
487   switch (F) {
488   case FieldId::F_type:
489     I->Type = std::move(R);
490     return llvm::Error::success();
491   default:
492     return llvm::createStringError(llvm::inconvertibleErrorCode(),
493                                    "invalid type cannot contain Reference");
494   }
495 }
496 
497 template <>
498 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
499   switch (F) {
500   case FieldId::F_type:
501     I->Type = std::move(R);
502     return llvm::Error::success();
503   default:
504     return llvm::createStringError(llvm::inconvertibleErrorCode(),
505                                    "invalid type cannot contain Reference");
506   }
507 }
508 
509 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
510   switch (F) {
511   case FieldId::F_namespace:
512     I->Namespace.emplace_back(std::move(R));
513     return llvm::Error::success();
514   default:
515     return llvm::createStringError(llvm::inconvertibleErrorCode(),
516                                    "invalid type cannot contain Reference");
517   }
518 }
519 
520 template <> llvm::Error addReference(TypedefInfo *I, Reference &&R, FieldId F) {
521   switch (F) {
522   case FieldId::F_namespace:
523     I->Namespace.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 <>
532 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
533   switch (F) {
534   case FieldId::F_namespace:
535     I->Namespace.emplace_back(std::move(R));
536     return llvm::Error::success();
537   case FieldId::F_child_namespace:
538     I->Children.Namespaces.emplace_back(std::move(R));
539     return llvm::Error::success();
540   case FieldId::F_child_record:
541     I->Children.Records.emplace_back(std::move(R));
542     return llvm::Error::success();
543   default:
544     return llvm::createStringError(llvm::inconvertibleErrorCode(),
545                                    "invalid type cannot contain Reference");
546   }
547 }
548 
549 template <>
550 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
551   switch (F) {
552   case FieldId::F_namespace:
553     I->Namespace.emplace_back(std::move(R));
554     return llvm::Error::success();
555   case FieldId::F_parent:
556     I->Parent = std::move(R);
557     return llvm::Error::success();
558   default:
559     return llvm::createStringError(llvm::inconvertibleErrorCode(),
560                                    "invalid type cannot contain Reference");
561   }
562 }
563 
564 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
565   switch (F) {
566   case FieldId::F_namespace:
567     I->Namespace.emplace_back(std::move(R));
568     return llvm::Error::success();
569   case FieldId::F_parent:
570     I->Parents.emplace_back(std::move(R));
571     return llvm::Error::success();
572   case FieldId::F_vparent:
573     I->VirtualParents.emplace_back(std::move(R));
574     return llvm::Error::success();
575   case FieldId::F_child_record:
576     I->Children.Records.emplace_back(std::move(R));
577     return llvm::Error::success();
578   default:
579     return llvm::createStringError(llvm::inconvertibleErrorCode(),
580                                    "invalid type cannot contain Reference");
581   }
582 }
583 
584 template <typename T, typename ChildInfoType>
585 void addChild(T I, ChildInfoType &&R) {
586   llvm::errs() << "invalid child type for info";
587   exit(1);
588 }
589 
590 // Namespace children:
591 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
592   I->Children.Functions.emplace_back(std::move(R));
593 }
594 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
595   I->Children.Enums.emplace_back(std::move(R));
596 }
597 template <> void addChild(NamespaceInfo *I, TypedefInfo &&R) {
598   I->Children.Typedefs.emplace_back(std::move(R));
599 }
600 
601 // Record children:
602 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
603   I->Children.Functions.emplace_back(std::move(R));
604 }
605 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
606   I->Children.Enums.emplace_back(std::move(R));
607 }
608 template <> void addChild(RecordInfo *I, TypedefInfo &&R) {
609   I->Children.Typedefs.emplace_back(std::move(R));
610 }
611 
612 // Other types of children:
613 template <> void addChild(EnumInfo *I, EnumValueInfo &&R) {
614   I->Members.emplace_back(std::move(R));
615 }
616 template <> void addChild(RecordInfo *I, BaseRecordInfo &&R) {
617   I->Bases.emplace_back(std::move(R));
618 }
619 template <> void addChild(BaseRecordInfo *I, FunctionInfo &&R) {
620   I->Children.Functions.emplace_back(std::move(R));
621 }
622 
623 // TemplateParam children. These go into either a TemplateInfo (for template
624 // parameters) or TemplateSpecializationInfo (for the specialization's
625 // parameters).
626 template <typename T> void addTemplateParam(T I, TemplateParamInfo &&P) {
627   llvm::errs() << "invalid container for template parameter";
628   exit(1);
629 }
630 template <> void addTemplateParam(TemplateInfo *I, TemplateParamInfo &&P) {
631   I->Params.emplace_back(std::move(P));
632 }
633 template <>
634 void addTemplateParam(TemplateSpecializationInfo *I, TemplateParamInfo &&P) {
635   I->Params.emplace_back(std::move(P));
636 }
637 
638 // Template info. These apply to either records or functions.
639 template <typename T> void addTemplate(T I, TemplateInfo &&P) {
640   llvm::errs() << "invalid container for template info";
641   exit(1);
642 }
643 template <> void addTemplate(RecordInfo *I, TemplateInfo &&P) {
644   I->Template.emplace(std::move(P));
645 }
646 template <> void addTemplate(FunctionInfo *I, TemplateInfo &&P) {
647   I->Template.emplace(std::move(P));
648 }
649 
650 // Template specializations go only into template records.
651 template <typename T>
652 void addTemplateSpecialization(T I, TemplateSpecializationInfo &&TSI) {
653   llvm::errs() << "invalid container for template specialization info";
654   exit(1);
655 }
656 template <>
657 void addTemplateSpecialization(TemplateInfo *I,
658                                TemplateSpecializationInfo &&TSI) {
659   I->Specialization.emplace(std::move(TSI));
660 }
661 
662 // Read records from bitcode into a given info.
663 template <typename T>
664 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
665   Record R;
666   llvm::StringRef Blob;
667   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
668   if (!MaybeRecID)
669     return MaybeRecID.takeError();
670   return parseRecord(R, MaybeRecID.get(), Blob, I);
671 }
672 
673 template <>
674 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
675   Record R;
676   llvm::StringRef Blob;
677   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
678   if (!MaybeRecID)
679     return MaybeRecID.takeError();
680   return parseRecord(R, MaybeRecID.get(), Blob, I, CurrentReferenceField);
681 }
682 
683 // Read a block of records into a single info.
684 template <typename T>
685 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
686   if (llvm::Error Err = Stream.EnterSubBlock(ID))
687     return Err;
688 
689   while (true) {
690     unsigned BlockOrCode = 0;
691     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
692 
693     switch (Res) {
694     case Cursor::BadBlock:
695       return llvm::createStringError(llvm::inconvertibleErrorCode(),
696                                      "bad block found");
697     case Cursor::BlockEnd:
698       return llvm::Error::success();
699     case Cursor::BlockBegin:
700       if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
701         if (llvm::Error Skipped = Stream.SkipBlock())
702           return joinErrors(std::move(Err), std::move(Skipped));
703         return Err;
704       }
705       continue;
706     case Cursor::Record:
707       break;
708     }
709     if (auto Err = readRecord(BlockOrCode, I))
710       return Err;
711   }
712 }
713 
714 template <typename T>
715 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
716   switch (ID) {
717   // Blocks can only have certain types of sub blocks.
718   case BI_COMMENT_BLOCK_ID: {
719     auto Comment = getCommentInfo(I);
720     if (!Comment)
721       return Comment.takeError();
722     if (auto Err = readBlock(ID, Comment.get()))
723       return Err;
724     return llvm::Error::success();
725   }
726   case BI_TYPE_BLOCK_ID: {
727     TypeInfo TI;
728     if (auto Err = readBlock(ID, &TI))
729       return Err;
730     if (auto Err = addTypeInfo(I, std::move(TI)))
731       return Err;
732     return llvm::Error::success();
733   }
734   case BI_FIELD_TYPE_BLOCK_ID: {
735     FieldTypeInfo TI;
736     if (auto Err = readBlock(ID, &TI))
737       return Err;
738     if (auto Err = addTypeInfo(I, std::move(TI)))
739       return Err;
740     return llvm::Error::success();
741   }
742   case BI_MEMBER_TYPE_BLOCK_ID: {
743     MemberTypeInfo TI;
744     if (auto Err = readBlock(ID, &TI))
745       return Err;
746     if (auto Err = addTypeInfo(I, std::move(TI)))
747       return Err;
748     return llvm::Error::success();
749   }
750   case BI_REFERENCE_BLOCK_ID: {
751     Reference R;
752     if (auto Err = readBlock(ID, &R))
753       return Err;
754     if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
755       return Err;
756     return llvm::Error::success();
757   }
758   case BI_FUNCTION_BLOCK_ID: {
759     FunctionInfo F;
760     if (auto Err = readBlock(ID, &F))
761       return Err;
762     addChild(I, std::move(F));
763     return llvm::Error::success();
764   }
765   case BI_BASE_RECORD_BLOCK_ID: {
766     BaseRecordInfo BR;
767     if (auto Err = readBlock(ID, &BR))
768       return Err;
769     addChild(I, std::move(BR));
770     return llvm::Error::success();
771   }
772   case BI_ENUM_BLOCK_ID: {
773     EnumInfo E;
774     if (auto Err = readBlock(ID, &E))
775       return Err;
776     addChild(I, std::move(E));
777     return llvm::Error::success();
778   }
779   case BI_ENUM_VALUE_BLOCK_ID: {
780     EnumValueInfo EV;
781     if (auto Err = readBlock(ID, &EV))
782       return Err;
783     addChild(I, std::move(EV));
784     return llvm::Error::success();
785   }
786   case BI_TEMPLATE_BLOCK_ID: {
787     TemplateInfo TI;
788     if (auto Err = readBlock(ID, &TI))
789       return Err;
790     addTemplate(I, std::move(TI));
791     return llvm::Error::success();
792   }
793   case BI_TEMPLATE_SPECIALIZATION_BLOCK_ID: {
794     TemplateSpecializationInfo TSI;
795     if (auto Err = readBlock(ID, &TSI))
796       return Err;
797     addTemplateSpecialization(I, std::move(TSI));
798     return llvm::Error::success();
799   }
800   case BI_TEMPLATE_PARAM_BLOCK_ID: {
801     TemplateParamInfo TPI;
802     if (auto Err = readBlock(ID, &TPI))
803       return Err;
804     addTemplateParam(I, std::move(TPI));
805     return llvm::Error::success();
806   }
807   case BI_TYPEDEF_BLOCK_ID: {
808     TypedefInfo TI;
809     if (auto Err = readBlock(ID, &TI))
810       return Err;
811     addChild(I, std::move(TI));
812     return llvm::Error::success();
813   }
814   default:
815     return llvm::createStringError(llvm::inconvertibleErrorCode(),
816                                    "invalid subblock type");
817   }
818 }
819 
820 ClangDocBitcodeReader::Cursor
821 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
822   BlockOrRecordID = 0;
823 
824   while (!Stream.AtEndOfStream()) {
825     Expected<unsigned> MaybeCode = Stream.ReadCode();
826     if (!MaybeCode) {
827       // FIXME this drops the error on the floor.
828       consumeError(MaybeCode.takeError());
829       return Cursor::BadBlock;
830     }
831 
832     unsigned Code = MaybeCode.get();
833     if (Code >= static_cast<unsigned>(llvm::bitc::FIRST_APPLICATION_ABBREV)) {
834       BlockOrRecordID = Code;
835       return Cursor::Record;
836     }
837     switch (static_cast<llvm::bitc::FixedAbbrevIDs>(Code)) {
838     case llvm::bitc::ENTER_SUBBLOCK:
839       if (Expected<unsigned> MaybeID = Stream.ReadSubBlockID())
840         BlockOrRecordID = MaybeID.get();
841       else {
842         // FIXME this drops the error on the floor.
843         consumeError(MaybeID.takeError());
844       }
845       return Cursor::BlockBegin;
846     case llvm::bitc::END_BLOCK:
847       if (Stream.ReadBlockEnd())
848         return Cursor::BadBlock;
849       return Cursor::BlockEnd;
850     case llvm::bitc::DEFINE_ABBREV:
851       if (llvm::Error Err = Stream.ReadAbbrevRecord()) {
852         // FIXME this drops the error on the floor.
853         consumeError(std::move(Err));
854       }
855       continue;
856     case llvm::bitc::UNABBREV_RECORD:
857       return Cursor::BadBlock;
858     case llvm::bitc::FIRST_APPLICATION_ABBREV:
859       llvm_unreachable("Unexpected abbrev id.");
860     }
861   }
862   llvm_unreachable("Premature stream end.");
863 }
864 
865 llvm::Error ClangDocBitcodeReader::validateStream() {
866   if (Stream.AtEndOfStream())
867     return llvm::createStringError(llvm::inconvertibleErrorCode(),
868                                    "premature end of stream");
869 
870   // Sniff for the signature.
871   for (int Idx = 0; Idx != 4; ++Idx) {
872     Expected<llvm::SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(8);
873     if (!MaybeRead)
874       return MaybeRead.takeError();
875     else if (MaybeRead.get() != BitCodeConstants::Signature[Idx])
876       return llvm::createStringError(llvm::inconvertibleErrorCode(),
877                                      "invalid bitcode signature");
878   }
879   return llvm::Error::success();
880 }
881 
882 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
883   Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
884       Stream.ReadBlockInfoBlock();
885   if (!MaybeBlockInfo)
886     return MaybeBlockInfo.takeError();
887   else
888     BlockInfo = MaybeBlockInfo.get();
889   if (!BlockInfo)
890     return llvm::createStringError(llvm::inconvertibleErrorCode(),
891                                    "unable to parse BlockInfoBlock");
892   Stream.setBlockInfo(&*BlockInfo);
893   return llvm::Error::success();
894 }
895 
896 template <typename T>
897 llvm::Expected<std::unique_ptr<Info>>
898 ClangDocBitcodeReader::createInfo(unsigned ID) {
899   std::unique_ptr<Info> I = std::make_unique<T>();
900   if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
901     return std::move(Err);
902   return std::unique_ptr<Info>{std::move(I)};
903 }
904 
905 llvm::Expected<std::unique_ptr<Info>>
906 ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
907   switch (ID) {
908   case BI_NAMESPACE_BLOCK_ID:
909     return createInfo<NamespaceInfo>(ID);
910   case BI_RECORD_BLOCK_ID:
911     return createInfo<RecordInfo>(ID);
912   case BI_ENUM_BLOCK_ID:
913     return createInfo<EnumInfo>(ID);
914   case BI_TYPEDEF_BLOCK_ID:
915     return createInfo<TypedefInfo>(ID);
916   case BI_FUNCTION_BLOCK_ID:
917     return createInfo<FunctionInfo>(ID);
918   default:
919     return llvm::createStringError(llvm::inconvertibleErrorCode(),
920                                    "cannot create info");
921   }
922 }
923 
924 // Entry point
925 llvm::Expected<std::vector<std::unique_ptr<Info>>>
926 ClangDocBitcodeReader::readBitcode() {
927   std::vector<std::unique_ptr<Info>> Infos;
928   if (auto Err = validateStream())
929     return std::move(Err);
930 
931   // Read the top level blocks.
932   while (!Stream.AtEndOfStream()) {
933     Expected<unsigned> MaybeCode = Stream.ReadCode();
934     if (!MaybeCode)
935       return MaybeCode.takeError();
936     if (MaybeCode.get() != llvm::bitc::ENTER_SUBBLOCK)
937       return llvm::createStringError(llvm::inconvertibleErrorCode(),
938                                      "no blocks in input");
939     Expected<unsigned> MaybeID = Stream.ReadSubBlockID();
940     if (!MaybeID)
941       return MaybeID.takeError();
942     unsigned ID = MaybeID.get();
943     switch (ID) {
944     // NamedType and Comment blocks should not appear at the top level
945     case BI_TYPE_BLOCK_ID:
946     case BI_FIELD_TYPE_BLOCK_ID:
947     case BI_MEMBER_TYPE_BLOCK_ID:
948     case BI_COMMENT_BLOCK_ID:
949     case BI_REFERENCE_BLOCK_ID:
950       return llvm::createStringError(llvm::inconvertibleErrorCode(),
951                                      "invalid top level block");
952     case BI_NAMESPACE_BLOCK_ID:
953     case BI_RECORD_BLOCK_ID:
954     case BI_ENUM_BLOCK_ID:
955     case BI_TYPEDEF_BLOCK_ID:
956     case BI_FUNCTION_BLOCK_ID: {
957       auto InfoOrErr = readBlockToInfo(ID);
958       if (!InfoOrErr)
959         return InfoOrErr.takeError();
960       Infos.emplace_back(std::move(InfoOrErr.get()));
961       continue;
962     }
963     case BI_VERSION_BLOCK_ID:
964       if (auto Err = readBlock(ID, VersionNumber))
965         return std::move(Err);
966       continue;
967     case llvm::bitc::BLOCKINFO_BLOCK_ID:
968       if (auto Err = readBlockInfoBlock())
969         return std::move(Err);
970       continue;
971     default:
972       if (llvm::Error Err = Stream.SkipBlock()) {
973         // FIXME this drops the error on the floor.
974         consumeError(std::move(Err));
975       }
976       continue;
977     }
978   }
979   return std::move(Infos);
980 }
981 
982 } // namespace doc
983 } // namespace clang
984