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