clang-tools-extra/clang-doc/BitcodeReader.cpp

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