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