clang/lib/APINotes/APINotesReader.cpp

   1 //===--- APINotesReader.cpp - API Notes 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 "clang/APINotes/APINotesReader.h"
  10 #include "APINotesFormat.h"
  11 #include "llvm/ADT/Hashing.h"
  12 #include "llvm/ADT/StringExtras.h"
  13 #include "llvm/Bitstream/BitstreamReader.h"
  14 #include "llvm/Support/DJB.h"
  15 #include "llvm/Support/EndianStream.h"
  16 #include "llvm/Support/OnDiskHashTable.h"
  17
  18 namespace clang {
  19 namespace api_notes {
  20 using namespace llvm::support;
  21
  22 namespace {
  23 /// Deserialize a version tuple.
  24 llvm::VersionTuple ReadVersionTuple(const uint8_t *&Data) {
  25   uint8_t NumVersions = (*Data++) & 0x03;
  26
  27   unsigned Major =
  28       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
  29   if (NumVersions == 0)
  30     return llvm::VersionTuple(Major);
  31
  32   unsigned Minor =
  33       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
  34   if (NumVersions == 1)
  35     return llvm::VersionTuple(Major, Minor);
  36
  37   unsigned Subminor =
  38       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
  39   if (NumVersions == 2)
  40     return llvm::VersionTuple(Major, Minor, Subminor);
  41
  42   unsigned Build =
  43       endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
  44   return llvm::VersionTuple(Major, Minor, Subminor, Build);
  45 }
  46
  47 /// An on-disk hash table whose data is versioned based on the Swift version.
  48 template <typename Derived, typename KeyType, typename UnversionedDataType>
  49 class VersionedTableInfo {
  50 public:
  51   using internal_key_type = KeyType;
  52   using external_key_type = KeyType;
  53   using data_type =
  54       llvm::SmallVector<std::pair<llvm::VersionTuple, UnversionedDataType>, 1>;
  55   using hash_value_type = size_t;
  56   using offset_type = unsigned;
  57
  58   internal_key_type GetInternalKey(external_key_type Key) { return Key; }
  59
  60   external_key_type GetExternalKey(internal_key_type Key) { return Key; }
  61
  62   static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
  63     return LHS == RHS;
  64   }
  65
  66   static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) {
  67     unsigned KeyLength =
  68         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
  69     unsigned DataLength =
  70         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
  71     return {KeyLength, DataLength};
  72   }
  73
  74   static data_type ReadData(internal_key_type Key, const uint8_t *Data,
  75                             unsigned Length) {
  76     unsigned NumElements =
  77         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
  78     data_type Result;
  79     Result.reserve(NumElements);
  80     for (unsigned i = 0; i != NumElements; ++i) {
  81       auto version = ReadVersionTuple(Data);
  82       const auto *DataBefore = Data;
  83       (void)DataBefore;
  84       assert(Data != DataBefore &&
  85              "Unversioned data reader didn't move pointer");
  86       auto UnversionedData = Derived::readUnversioned(Key, Data);
  87       Result.push_back({version, UnversionedData});
  88     }
  89     return Result;
  90   }
  91 };
  92
  93 /// Read serialized CommonEntityInfo.
  94 void ReadCommonEntityInfo(const uint8_t *&Data, CommonEntityInfo &Info) {
  95   uint8_t UnavailableBits = *Data++;
  96   Info.Unavailable = (UnavailableBits >> 1) & 0x01;
  97   Info.UnavailableInSwift = UnavailableBits & 0x01;
  98   if ((UnavailableBits >> 2) & 0x01)
  99     Info.setSwiftPrivate(static_cast<bool>((UnavailableBits >> 3) & 0x01));
 100
 101   unsigned MsgLength =
 102       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 103   Info.UnavailableMsg =
 104       std::string(reinterpret_cast<const char *>(Data),
 105                   reinterpret_cast<const char *>(Data) + MsgLength);
 106   Data += MsgLength;
 107
 108   unsigned SwiftNameLength =
 109       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 110   Info.SwiftName =
 111       std::string(reinterpret_cast<const char *>(Data),
 112                   reinterpret_cast<const char *>(Data) + SwiftNameLength);
 113   Data += SwiftNameLength;
 114 }
 115
 116 /// Read serialized CommonTypeInfo.
 117 void ReadCommonTypeInfo(const uint8_t *&Data, CommonTypeInfo &Info) {
 118   ReadCommonEntityInfo(Data, Info);
 119
 120   unsigned SwiftBridgeLength =
 121       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 122   if (SwiftBridgeLength > 0) {
 123     Info.setSwiftBridge(std::string(reinterpret_cast<const char *>(Data),
 124                                     SwiftBridgeLength - 1));
 125     Data += SwiftBridgeLength - 1;
 126   }
 127
 128   unsigned ErrorDomainLength =
 129       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 130   if (ErrorDomainLength > 0) {
 131     Info.setNSErrorDomain(std::optional<std::string>(std::string(
 132         reinterpret_cast<const char *>(Data), ErrorDomainLength - 1)));
 133     Data += ErrorDomainLength - 1;
 134   }
 135 }
 136
 137 /// Used to deserialize the on-disk identifier table.
 138 class IdentifierTableInfo {
 139 public:
 140   using internal_key_type = llvm::StringRef;
 141   using external_key_type = llvm::StringRef;
 142   using data_type = IdentifierID;
 143   using hash_value_type = uint32_t;
 144   using offset_type = unsigned;
 145
 146   internal_key_type GetInternalKey(external_key_type Key) { return Key; }
 147
 148   external_key_type GetExternalKey(internal_key_type Key) { return Key; }
 149
 150   hash_value_type ComputeHash(internal_key_type Key) {
 151     return llvm::hash_value(Key);
 152   }
 153
 154   static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
 155     return LHS == RHS;
 156   }
 157
 158   static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) {
 159     unsigned KeyLength =
 160         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 161     unsigned DataLength =
 162         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 163     return {KeyLength, DataLength};
 164   }
 165
 166   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 167     return llvm::StringRef(reinterpret_cast<const char *>(Data), Length);
 168   }
 169
 170   static data_type ReadData(internal_key_type key, const uint8_t *Data,
 171                             unsigned Length) {
 172     return endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
 173         Data);
 174   }
 175 };
 176
 177 /// Used to deserialize the on-disk Objective-C class table.
 178 class ObjCContextIDTableInfo {
 179 public:
 180   using internal_key_type = ContextTableKey;
 181   using external_key_type = internal_key_type;
 182   using data_type = unsigned;
 183   using hash_value_type = size_t;
 184   using offset_type = unsigned;
 185
 186   internal_key_type GetInternalKey(external_key_type Key) { return Key; }
 187
 188   external_key_type GetExternalKey(internal_key_type Key) { return Key; }
 189
 190   hash_value_type ComputeHash(internal_key_type Key) {
 191     return static_cast<size_t>(Key.hashValue());
 192   }
 193
 194   static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
 195     return LHS == RHS;
 196   }
 197
 198   static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) {
 199     unsigned KeyLength =
 200         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 201     unsigned DataLength =
 202         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 203     return {KeyLength, DataLength};
 204   }
 205
 206   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 207     auto ParentCtxID =
 208         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 209     auto ContextKind =
 210         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 211     auto NameID =
 212         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 213     return {ParentCtxID, ContextKind, NameID};
 214   }
 215
 216   static data_type ReadData(internal_key_type Key, const uint8_t *Data,
 217                             unsigned Length) {
 218     return endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
 219         Data);
 220   }
 221 };
 222
 223 /// Used to deserialize the on-disk Objective-C property table.
 224 class ObjCContextInfoTableInfo
 225     : public VersionedTableInfo<ObjCContextInfoTableInfo, unsigned,
 226                                 ObjCContextInfo> {
 227 public:
 228   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 229     return endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
 230         Data);
 231   }
 232
 233   hash_value_type ComputeHash(internal_key_type Key) {
 234     return static_cast<size_t>(llvm::hash_value(Key));
 235   }
 236
 237   static ObjCContextInfo readUnversioned(internal_key_type Key,
 238                                          const uint8_t *&Data) {
 239     ObjCContextInfo Info;
 240     ReadCommonTypeInfo(Data, Info);
 241     uint8_t Payload = *Data++;
 242
 243     if (Payload & 0x01)
 244       Info.setHasDesignatedInits(true);
 245     Payload = Payload >> 1;
 246
 247     if (Payload & 0x4)
 248       Info.setDefaultNullability(static_cast<NullabilityKind>(Payload & 0x03));
 249     Payload >>= 3;
 250
 251     if (Payload & (1 << 1))
 252       Info.setSwiftObjCMembers(Payload & 1);
 253     Payload >>= 2;
 254
 255     if (Payload & (1 << 1))
 256       Info.setSwiftImportAsNonGeneric(Payload & 1);
 257
 258     return Info;
 259   }
 260 };
 261
 262 /// Read serialized VariableInfo.
 263 void ReadVariableInfo(const uint8_t *&Data, VariableInfo &Info) {
 264   ReadCommonEntityInfo(Data, Info);
 265   if (*Data++) {
 266     Info.setNullabilityAudited(static_cast<NullabilityKind>(*Data));
 267   }
 268   ++Data;
 269
 270   auto TypeLen =
 271       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 272   Info.setType(std::string(Data, Data + TypeLen));
 273   Data += TypeLen;
 274 }
 275
 276 /// Used to deserialize the on-disk Objective-C property table.
 277 class ObjCPropertyTableInfo
 278     : public VersionedTableInfo<ObjCPropertyTableInfo,
 279                                 std::tuple<uint32_t, uint32_t, uint8_t>,
 280                                 ObjCPropertyInfo> {
 281 public:
 282   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 283     auto ClassID =
 284         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 285     auto NameID =
 286         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 287     char IsInstance =
 288         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 289     return {ClassID, NameID, IsInstance};
 290   }
 291
 292   hash_value_type ComputeHash(internal_key_type Key) {
 293     return static_cast<size_t>(llvm::hash_value(Key));
 294   }
 295
 296   static ObjCPropertyInfo readUnversioned(internal_key_type Key,
 297                                           const uint8_t *&Data) {
 298     ObjCPropertyInfo Info;
 299     ReadVariableInfo(Data, Info);
 300     uint8_t Flags = *Data++;
 301     if (Flags & (1 << 0))
 302       Info.setSwiftImportAsAccessors(Flags & (1 << 1));
 303     return Info;
 304   }
 305 };
 306
 307 /// Read serialized ParamInfo.
 308 void ReadParamInfo(const uint8_t *&Data, ParamInfo &Info) {
 309   ReadVariableInfo(Data, Info);
 310
 311   uint8_t Payload =
 312       endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 313   if (auto RawConvention = Payload & 0x7) {
 314     auto Convention = static_cast<RetainCountConventionKind>(RawConvention - 1);
 315     Info.setRetainCountConvention(Convention);
 316   }
 317   Payload >>= 3;
 318   if (Payload & 0x01)
 319     Info.setNoEscape(Payload & 0x02);
 320   Payload >>= 2;
 321   assert(Payload == 0 && "Bad API notes");
 322 }
 323
 324 /// Read serialized FunctionInfo.
 325 void ReadFunctionInfo(const uint8_t *&Data, FunctionInfo &Info) {
 326   ReadCommonEntityInfo(Data, Info);
 327
 328   uint8_t Payload =
 329       endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 330   if (auto RawConvention = Payload & 0x7) {
 331     auto Convention = static_cast<RetainCountConventionKind>(RawConvention - 1);
 332     Info.setRetainCountConvention(Convention);
 333   }
 334   Payload >>= 3;
 335   Info.NullabilityAudited = Payload & 0x1;
 336   Payload >>= 1;
 337   assert(Payload == 0 && "Bad API notes");
 338
 339   Info.NumAdjustedNullable =
 340       endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 341   Info.NullabilityPayload =
 342       endian::readNext<uint64_t, llvm::endianness::little, unaligned>(Data);
 343
 344   unsigned NumParams =
 345       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 346   while (NumParams > 0) {
 347     ParamInfo pi;
 348     ReadParamInfo(Data, pi);
 349     Info.Params.push_back(pi);
 350     --NumParams;
 351   }
 352
 353   unsigned ResultTypeLen =
 354       endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 355   Info.ResultType = std::string(Data, Data + ResultTypeLen);
 356   Data += ResultTypeLen;
 357 }
 358
 359 /// Used to deserialize the on-disk Objective-C method table.
 360 class ObjCMethodTableInfo
 361     : public VersionedTableInfo<ObjCMethodTableInfo,
 362                                 std::tuple<uint32_t, uint32_t, uint8_t>,
 363                                 ObjCMethodInfo> {
 364 public:
 365   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 366     auto ClassID =
 367         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 368     auto SelectorID =
 369         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 370     auto IsInstance =
 371         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 372     return {ClassID, SelectorID, IsInstance};
 373   }
 374
 375   hash_value_type ComputeHash(internal_key_type Key) {
 376     return static_cast<size_t>(llvm::hash_value(Key));
 377   }
 378
 379   static ObjCMethodInfo readUnversioned(internal_key_type Key,
 380                                         const uint8_t *&Data) {
 381     ObjCMethodInfo Info;
 382     uint8_t Payload = *Data++;
 383     Info.RequiredInit = Payload & 0x01;
 384     Payload >>= 1;
 385     Info.DesignatedInit = Payload & 0x01;
 386     Payload >>= 1;
 387
 388     ReadFunctionInfo(Data, Info);
 389     return Info;
 390   }
 391 };
 392
 393 /// Used to deserialize the on-disk Objective-C selector table.
 394 class ObjCSelectorTableInfo {
 395 public:
 396   using internal_key_type = StoredObjCSelector;
 397   using external_key_type = internal_key_type;
 398   using data_type = SelectorID;
 399   using hash_value_type = unsigned;
 400   using offset_type = unsigned;
 401
 402   internal_key_type GetInternalKey(external_key_type Key) { return Key; }
 403
 404   external_key_type GetExternalKey(internal_key_type Key) { return Key; }
 405
 406   hash_value_type ComputeHash(internal_key_type Key) {
 407     return llvm::DenseMapInfo<StoredObjCSelector>::getHashValue(Key);
 408   }
 409
 410   static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
 411     return llvm::DenseMapInfo<StoredObjCSelector>::isEqual(LHS, RHS);
 412   }
 413
 414   static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) {
 415     unsigned KeyLength =
 416         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 417     unsigned DataLength =
 418         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 419     return {KeyLength, DataLength};
 420   }
 421
 422   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 423     internal_key_type Key;
 424     Key.NumArgs =
 425         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 426     unsigned NumIdents = (Length - sizeof(uint16_t)) / sizeof(uint32_t);
 427     for (unsigned i = 0; i != NumIdents; ++i) {
 428       Key.Identifiers.push_back(
 429           endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
 430               Data));
 431     }
 432     return Key;
 433   }
 434
 435   static data_type ReadData(internal_key_type Key, const uint8_t *Data,
 436                             unsigned Length) {
 437     return endian::readNext<uint32_t, llvm::endianness::little, unaligned>(
 438         Data);
 439   }
 440 };
 441
 442 /// Used to deserialize the on-disk global variable table.
 443 class GlobalVariableTableInfo
 444     : public VersionedTableInfo<GlobalVariableTableInfo, ContextTableKey,
 445                                 GlobalVariableInfo> {
 446 public:
 447   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 448     auto CtxID =
 449         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 450     auto ContextKind =
 451         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 452     auto NameID =
 453         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 454     return {CtxID, ContextKind, NameID};
 455   }
 456
 457   hash_value_type ComputeHash(internal_key_type Key) {
 458     return static_cast<size_t>(Key.hashValue());
 459   }
 460
 461   static GlobalVariableInfo readUnversioned(internal_key_type Key,
 462                                             const uint8_t *&Data) {
 463     GlobalVariableInfo Info;
 464     ReadVariableInfo(Data, Info);
 465     return Info;
 466   }
 467 };
 468
 469 /// Used to deserialize the on-disk global function table.
 470 class GlobalFunctionTableInfo
 471     : public VersionedTableInfo<GlobalFunctionTableInfo, ContextTableKey,
 472                                 GlobalFunctionInfo> {
 473 public:
 474   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 475     auto CtxID =
 476         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 477     auto ContextKind =
 478         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 479     auto NameID =
 480         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 481     return {CtxID, ContextKind, NameID};
 482   }
 483
 484   hash_value_type ComputeHash(internal_key_type Key) {
 485     return static_cast<size_t>(Key.hashValue());
 486   }
 487
 488   static GlobalFunctionInfo readUnversioned(internal_key_type Key,
 489                                             const uint8_t *&Data) {
 490     GlobalFunctionInfo Info;
 491     ReadFunctionInfo(Data, Info);
 492     return Info;
 493   }
 494 };
 495
 496 /// Used to deserialize the on-disk enumerator table.
 497 class EnumConstantTableInfo
 498     : public VersionedTableInfo<EnumConstantTableInfo, uint32_t,
 499                                 EnumConstantInfo> {
 500 public:
 501   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 502     auto NameID =
 503         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 504     return NameID;
 505   }
 506
 507   hash_value_type ComputeHash(internal_key_type Key) {
 508     return static_cast<size_t>(llvm::hash_value(Key));
 509   }
 510
 511   static EnumConstantInfo readUnversioned(internal_key_type Key,
 512                                           const uint8_t *&Data) {
 513     EnumConstantInfo Info;
 514     ReadCommonEntityInfo(Data, Info);
 515     return Info;
 516   }
 517 };
 518
 519 /// Used to deserialize the on-disk tag table.
 520 class TagTableInfo
 521     : public VersionedTableInfo<TagTableInfo, ContextTableKey, TagInfo> {
 522 public:
 523   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 524     auto CtxID =
 525         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 526     auto ContextKind =
 527         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 528     auto NameID =
 529         endian::readNext<IdentifierID, llvm::endianness::little, unaligned>(
 530             Data);
 531     return {CtxID, ContextKind, NameID};
 532   }
 533
 534   hash_value_type ComputeHash(internal_key_type Key) {
 535     return static_cast<size_t>(Key.hashValue());
 536   }
 537
 538   static TagInfo readUnversioned(internal_key_type Key, const uint8_t *&Data) {
 539     TagInfo Info;
 540
 541     uint8_t Payload = *Data++;
 542     if (Payload & 1)
 543       Info.setFlagEnum(Payload & 2);
 544     Payload >>= 2;
 545     if (Payload > 0)
 546       Info.EnumExtensibility =
 547           static_cast<EnumExtensibilityKind>((Payload & 0x3) - 1);
 548
 549     unsigned ImportAsLength =
 550         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 551     if (ImportAsLength > 0) {
 552       Info.SwiftImportAs =
 553           std::string(reinterpret_cast<const char *>(Data), ImportAsLength - 1);
 554       Data += ImportAsLength - 1;
 555     }
 556     unsigned RetainOpLength =
 557         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 558     if (RetainOpLength > 0) {
 559       Info.SwiftRetainOp =
 560           std::string(reinterpret_cast<const char *>(Data), RetainOpLength - 1);
 561       Data += RetainOpLength - 1;
 562     }
 563     unsigned ReleaseOpLength =
 564         endian::readNext<uint16_t, llvm::endianness::little, unaligned>(Data);
 565     if (ReleaseOpLength > 0) {
 566       Info.SwiftReleaseOp = std::string(reinterpret_cast<const char *>(Data),
 567                                         ReleaseOpLength - 1);
 568       Data += ReleaseOpLength - 1;
 569     }
 570
 571     ReadCommonTypeInfo(Data, Info);
 572     return Info;
 573   }
 574 };
 575
 576 /// Used to deserialize the on-disk typedef table.
 577 class TypedefTableInfo
 578     : public VersionedTableInfo<TypedefTableInfo, ContextTableKey,
 579                                 TypedefInfo> {
 580 public:
 581   static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) {
 582     auto CtxID =
 583         endian::readNext<uint32_t, llvm::endianness::little, unaligned>(Data);
 584     auto ContextKind =
 585         endian::readNext<uint8_t, llvm::endianness::little, unaligned>(Data);
 586     auto nameID =
 587         endian::readNext<IdentifierID, llvm::endianness::little, unaligned>(
 588             Data);
 589     return {CtxID, ContextKind, nameID};
 590   }
 591
 592   hash_value_type ComputeHash(internal_key_type Key) {
 593     return static_cast<size_t>(Key.hashValue());
 594   }
 595
 596   static TypedefInfo readUnversioned(internal_key_type Key,
 597                                      const uint8_t *&Data) {
 598     TypedefInfo Info;
 599
 600     uint8_t Payload = *Data++;
 601     if (Payload > 0)
 602       Info.SwiftWrapper = static_cast<SwiftNewTypeKind>((Payload & 0x3) - 1);
 603
 604     ReadCommonTypeInfo(Data, Info);
 605     return Info;
 606   }
 607 };
 608 } // end anonymous namespace
 609
 610 class APINotesReader::Implementation {
 611 public:
 612   /// The input buffer for the API notes data.
 613   llvm::MemoryBuffer *InputBuffer;
 614
 615   /// The Swift version to use for filtering.
 616   llvm::VersionTuple SwiftVersion;
 617
 618   /// The name of the module that we read from the control block.
 619   std::string ModuleName;
 620
 621   // The size and modification time of the source file from
 622   // which this API notes file was created, if known.
 623   std::optional<std::pair<off_t, time_t>> SourceFileSizeAndModTime;
 624
 625   using SerializedIdentifierTable =
 626       llvm::OnDiskIterableChainedHashTable<IdentifierTableInfo>;
 627
 628   /// The identifier table.
 629   std::unique_ptr<SerializedIdentifierTable> IdentifierTable;
 630
 631   using SerializedObjCContextIDTable =
 632       llvm::OnDiskIterableChainedHashTable<ObjCContextIDTableInfo>;
 633
 634   /// The Objective-C context ID table.
 635   std::unique_ptr<SerializedObjCContextIDTable> ObjCContextIDTable;
 636
 637   using SerializedObjCContextInfoTable =
 638       llvm::OnDiskIterableChainedHashTable<ObjCContextInfoTableInfo>;
 639
 640   /// The Objective-C context info table.
 641   std::unique_ptr<SerializedObjCContextInfoTable> ObjCContextInfoTable;
 642
 643   using SerializedObjCPropertyTable =
 644       llvm::OnDiskIterableChainedHashTable<ObjCPropertyTableInfo>;
 645
 646   /// The Objective-C property table.
 647   std::unique_ptr<SerializedObjCPropertyTable> ObjCPropertyTable;
 648
 649   using SerializedObjCMethodTable =
 650       llvm::OnDiskIterableChainedHashTable<ObjCMethodTableInfo>;
 651
 652   /// The Objective-C method table.
 653   std::unique_ptr<SerializedObjCMethodTable> ObjCMethodTable;
 654
 655   using SerializedObjCSelectorTable =
 656       llvm::OnDiskIterableChainedHashTable<ObjCSelectorTableInfo>;
 657
 658   /// The Objective-C selector table.
 659   std::unique_ptr<SerializedObjCSelectorTable> ObjCSelectorTable;
 660
 661   using SerializedGlobalVariableTable =
 662       llvm::OnDiskIterableChainedHashTable<GlobalVariableTableInfo>;
 663
 664   /// The global variable table.
 665   std::unique_ptr<SerializedGlobalVariableTable> GlobalVariableTable;
 666
 667   using SerializedGlobalFunctionTable =
 668       llvm::OnDiskIterableChainedHashTable<GlobalFunctionTableInfo>;
 669
 670   /// The global function table.
 671   std::unique_ptr<SerializedGlobalFunctionTable> GlobalFunctionTable;
 672
 673   using SerializedEnumConstantTable =
 674       llvm::OnDiskIterableChainedHashTable<EnumConstantTableInfo>;
 675
 676   /// The enumerator table.
 677   std::unique_ptr<SerializedEnumConstantTable> EnumConstantTable;
 678
 679   using SerializedTagTable = llvm::OnDiskIterableChainedHashTable<TagTableInfo>;
 680
 681   /// The tag table.
 682   std::unique_ptr<SerializedTagTable> TagTable;
 683
 684   using SerializedTypedefTable =
 685       llvm::OnDiskIterableChainedHashTable<TypedefTableInfo>;
 686
 687   /// The typedef table.
 688   std::unique_ptr<SerializedTypedefTable> TypedefTable;
 689
 690   /// Retrieve the identifier ID for the given string, or an empty
 691   /// optional if the string is unknown.
 692   std::optional<IdentifierID> getIdentifier(llvm::StringRef Str);
 693
 694   /// Retrieve the selector ID for the given selector, or an empty
 695   /// optional if the string is unknown.
 696   std::optional<SelectorID> getSelector(ObjCSelectorRef Selector);
 697
 698   bool readControlBlock(llvm::BitstreamCursor &Cursor,
 699                         llvm::SmallVectorImpl<uint64_t> &Scratch);
 700   bool readIdentifierBlock(llvm::BitstreamCursor &Cursor,
 701                            llvm::SmallVectorImpl<uint64_t> &Scratch);
 702   bool readObjCContextBlock(llvm::BitstreamCursor &Cursor,
 703                             llvm::SmallVectorImpl<uint64_t> &Scratch);
 704   bool readObjCPropertyBlock(llvm::BitstreamCursor &Cursor,
 705                              llvm::SmallVectorImpl<uint64_t> &Scratch);
 706   bool readObjCMethodBlock(llvm::BitstreamCursor &Cursor,
 707                            llvm::SmallVectorImpl<uint64_t> &Scratch);
 708   bool readObjCSelectorBlock(llvm::BitstreamCursor &Cursor,
 709                              llvm::SmallVectorImpl<uint64_t> &Scratch);
 710   bool readGlobalVariableBlock(llvm::BitstreamCursor &Cursor,
 711                                llvm::SmallVectorImpl<uint64_t> &Scratch);
 712   bool readGlobalFunctionBlock(llvm::BitstreamCursor &Cursor,
 713                                llvm::SmallVectorImpl<uint64_t> &Scratch);
 714   bool readEnumConstantBlock(llvm::BitstreamCursor &Cursor,
 715                              llvm::SmallVectorImpl<uint64_t> &Scratch);
 716   bool readTagBlock(llvm::BitstreamCursor &Cursor,
 717                     llvm::SmallVectorImpl<uint64_t> &Scratch);
 718   bool readTypedefBlock(llvm::BitstreamCursor &Cursor,
 719                         llvm::SmallVectorImpl<uint64_t> &Scratch);
 720 };
 721
 722 std::optional<IdentifierID>
 723 APINotesReader::Implementation::getIdentifier(llvm::StringRef Str) {
 724   if (!IdentifierTable)
 725     return std::nullopt;
 726
 727   if (Str.empty())
 728     return IdentifierID(0);
 729
 730   auto Known = IdentifierTable->find(Str);
 731   if (Known == IdentifierTable->end())
 732     return std::nullopt;
 733
 734   return *Known;
 735 }
 736
 737 std::optional<SelectorID>
 738 APINotesReader::Implementation::getSelector(ObjCSelectorRef Selector) {
 739   if (!ObjCSelectorTable || !IdentifierTable)
 740     return std::nullopt;
 741
 742   // Translate the identifiers.
 743   StoredObjCSelector Key;
 744   Key.NumArgs = Selector.NumArgs;
 745   for (auto Ident : Selector.Identifiers) {
 746     if (auto IdentID = getIdentifier(Ident)) {
 747       Key.Identifiers.push_back(*IdentID);
 748     } else {
 749       return std::nullopt;
 750     }
 751   }
 752
 753   auto Known = ObjCSelectorTable->find(Key);
 754   if (Known == ObjCSelectorTable->end())
 755     return std::nullopt;
 756
 757   return *Known;
 758 }
 759
 760 bool APINotesReader::Implementation::readControlBlock(
 761     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
 762   if (Cursor.EnterSubBlock(CONTROL_BLOCK_ID))
 763     return true;
 764
 765   bool SawMetadata = false;
 766
 767   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
 768   if (!MaybeNext) {
 769     // FIXME this drops the error on the floor.
 770     consumeError(MaybeNext.takeError());
 771     return false;
 772   }
 773   llvm::BitstreamEntry Next = MaybeNext.get();
 774
 775   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
 776     if (Next.Kind == llvm::BitstreamEntry::Error)
 777       return true;
 778
 779     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
 780       // Unknown metadata sub-block, possibly for use by a future version of the
 781       // API notes format.
 782       if (Cursor.SkipBlock())
 783         return true;
 784
 785       MaybeNext = Cursor.advance();
 786       if (!MaybeNext) {
 787         // FIXME this drops the error on the floor.
 788         consumeError(MaybeNext.takeError());
 789         return false;
 790       }
 791       Next = MaybeNext.get();
 792       continue;
 793     }
 794
 795     Scratch.clear();
 796     llvm::StringRef BlobData;
 797     llvm::Expected<unsigned> MaybeKind =
 798         Cursor.readRecord(Next.ID, Scratch, &BlobData);
 799     if (!MaybeKind) {
 800       // FIXME this drops the error on the floor.
 801       consumeError(MaybeKind.takeError());
 802       return false;
 803     }
 804     unsigned Kind = MaybeKind.get();
 805
 806     switch (Kind) {
 807     case control_block::METADATA:
 808       // Already saw metadata.
 809       if (SawMetadata)
 810         return true;
 811
 812       if (Scratch[0] != VERSION_MAJOR || Scratch[1] != VERSION_MINOR)
 813         return true;
 814
 815       SawMetadata = true;
 816       break;
 817
 818     case control_block::MODULE_NAME:
 819       ModuleName = BlobData.str();
 820       break;
 821
 822     case control_block::MODULE_OPTIONS:
 823       break;
 824
 825     case control_block::SOURCE_FILE:
 826       SourceFileSizeAndModTime = {Scratch[0], Scratch[1]};
 827       break;
 828
 829     default:
 830       // Unknown metadata record, possibly for use by a future version of the
 831       // module format.
 832       break;
 833     }
 834
 835     MaybeNext = Cursor.advance();
 836     if (!MaybeNext) {
 837       // FIXME this drops the error on the floor.
 838       consumeError(MaybeNext.takeError());
 839       return false;
 840     }
 841     Next = MaybeNext.get();
 842   }
 843
 844   return !SawMetadata;
 845 }
 846
 847 bool APINotesReader::Implementation::readIdentifierBlock(
 848     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
 849   if (Cursor.EnterSubBlock(IDENTIFIER_BLOCK_ID))
 850     return true;
 851
 852   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
 853   if (!MaybeNext) {
 854     // FIXME this drops the error on the floor.
 855     consumeError(MaybeNext.takeError());
 856     return false;
 857   }
 858   llvm::BitstreamEntry Next = MaybeNext.get();
 859
 860   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
 861     if (Next.Kind == llvm::BitstreamEntry::Error)
 862       return true;
 863
 864     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
 865       // Unknown sub-block, possibly for use by a future version of the
 866       // API notes format.
 867       if (Cursor.SkipBlock())
 868         return true;
 869
 870       MaybeNext = Cursor.advance();
 871       if (!MaybeNext) {
 872         // FIXME this drops the error on the floor.
 873         consumeError(MaybeNext.takeError());
 874         return false;
 875       }
 876       Next = MaybeNext.get();
 877       continue;
 878     }
 879
 880     Scratch.clear();
 881     llvm::StringRef BlobData;
 882     llvm::Expected<unsigned> MaybeKind =
 883         Cursor.readRecord(Next.ID, Scratch, &BlobData);
 884     if (!MaybeKind) {
 885       // FIXME this drops the error on the floor.
 886       consumeError(MaybeKind.takeError());
 887       return false;
 888     }
 889     unsigned Kind = MaybeKind.get();
 890     switch (Kind) {
 891     case identifier_block::IDENTIFIER_DATA: {
 892       // Already saw identifier table.
 893       if (IdentifierTable)
 894         return true;
 895
 896       uint32_t tableOffset;
 897       identifier_block::IdentifierDataLayout::readRecord(Scratch, tableOffset);
 898       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
 899
 900       IdentifierTable.reset(SerializedIdentifierTable::Create(
 901           base + tableOffset, base + sizeof(uint32_t), base));
 902       break;
 903     }
 904
 905     default:
 906       // Unknown record, possibly for use by a future version of the
 907       // module format.
 908       break;
 909     }
 910
 911     MaybeNext = Cursor.advance();
 912     if (!MaybeNext) {
 913       // FIXME this drops the error on the floor.
 914       consumeError(MaybeNext.takeError());
 915       return false;
 916     }
 917     Next = MaybeNext.get();
 918   }
 919
 920   return false;
 921 }
 922
 923 bool APINotesReader::Implementation::readObjCContextBlock(
 924     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
 925   if (Cursor.EnterSubBlock(OBJC_CONTEXT_BLOCK_ID))
 926     return true;
 927
 928   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
 929   if (!MaybeNext) {
 930     // FIXME this drops the error on the floor.
 931     consumeError(MaybeNext.takeError());
 932     return false;
 933   }
 934   llvm::BitstreamEntry Next = MaybeNext.get();
 935
 936   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
 937     if (Next.Kind == llvm::BitstreamEntry::Error)
 938       return true;
 939
 940     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
 941       // Unknown sub-block, possibly for use by a future version of the
 942       // API notes format.
 943       if (Cursor.SkipBlock())
 944         return true;
 945
 946       MaybeNext = Cursor.advance();
 947       if (!MaybeNext) {
 948         // FIXME this drops the error on the floor.
 949         consumeError(MaybeNext.takeError());
 950         return false;
 951       }
 952       Next = MaybeNext.get();
 953       continue;
 954     }
 955
 956     Scratch.clear();
 957     llvm::StringRef BlobData;
 958     llvm::Expected<unsigned> MaybeKind =
 959         Cursor.readRecord(Next.ID, Scratch, &BlobData);
 960     if (!MaybeKind) {
 961       // FIXME this drops the error on the floor.
 962       consumeError(MaybeKind.takeError());
 963       return false;
 964     }
 965     unsigned Kind = MaybeKind.get();
 966     switch (Kind) {
 967     case objc_context_block::OBJC_CONTEXT_ID_DATA: {
 968       // Already saw Objective-C context ID table.
 969       if (ObjCContextIDTable)
 970         return true;
 971
 972       uint32_t tableOffset;
 973       objc_context_block::ObjCContextIDLayout::readRecord(Scratch, tableOffset);
 974       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
 975
 976       ObjCContextIDTable.reset(SerializedObjCContextIDTable::Create(
 977           base + tableOffset, base + sizeof(uint32_t), base));
 978       break;
 979     }
 980
 981     case objc_context_block::OBJC_CONTEXT_INFO_DATA: {
 982       // Already saw Objective-C context info table.
 983       if (ObjCContextInfoTable)
 984         return true;
 985
 986       uint32_t tableOffset;
 987       objc_context_block::ObjCContextInfoLayout::readRecord(Scratch,
 988                                                             tableOffset);
 989       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
 990
 991       ObjCContextInfoTable.reset(SerializedObjCContextInfoTable::Create(
 992           base + tableOffset, base + sizeof(uint32_t), base));
 993       break;
 994     }
 995
 996     default:
 997       // Unknown record, possibly for use by a future version of the
 998       // module format.
 999       break;
1000     }
1001
1002     MaybeNext = Cursor.advance();
1003     if (!MaybeNext) {
1004       // FIXME this drops the error on the floor.
1005       consumeError(MaybeNext.takeError());
1006       return false;
1007     }
1008     Next = MaybeNext.get();
1009   }
1010
1011   return false;
1012 }
1013
1014 bool APINotesReader::Implementation::readObjCPropertyBlock(
1015     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1016   if (Cursor.EnterSubBlock(OBJC_PROPERTY_BLOCK_ID))
1017     return true;
1018
1019   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1020   if (!MaybeNext) {
1021     // FIXME this drops the error on the floor.
1022     consumeError(MaybeNext.takeError());
1023     return false;
1024   }
1025   llvm::BitstreamEntry Next = MaybeNext.get();
1026
1027   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1028     if (Next.Kind == llvm::BitstreamEntry::Error)
1029       return true;
1030
1031     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1032       // Unknown sub-block, possibly for use by a future version of the
1033       // API notes format.
1034       if (Cursor.SkipBlock())
1035         return true;
1036
1037       MaybeNext = Cursor.advance();
1038       if (!MaybeNext) {
1039         // FIXME this drops the error on the floor.
1040         consumeError(MaybeNext.takeError());
1041         return false;
1042       }
1043       Next = MaybeNext.get();
1044       continue;
1045     }
1046
1047     Scratch.clear();
1048     llvm::StringRef BlobData;
1049     llvm::Expected<unsigned> MaybeKind =
1050         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1051     if (!MaybeKind) {
1052       // FIXME this drops the error on the floor.
1053       consumeError(MaybeKind.takeError());
1054       return false;
1055     }
1056     unsigned Kind = MaybeKind.get();
1057     switch (Kind) {
1058     case objc_property_block::OBJC_PROPERTY_DATA: {
1059       // Already saw Objective-C property table.
1060       if (ObjCPropertyTable)
1061         return true;
1062
1063       uint32_t tableOffset;
1064       objc_property_block::ObjCPropertyDataLayout::readRecord(Scratch,
1065                                                               tableOffset);
1066       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1067
1068       ObjCPropertyTable.reset(SerializedObjCPropertyTable::Create(
1069           base + tableOffset, base + sizeof(uint32_t), base));
1070       break;
1071     }
1072
1073     default:
1074       // Unknown record, possibly for use by a future version of the
1075       // module format.
1076       break;
1077     }
1078
1079     MaybeNext = Cursor.advance();
1080     if (!MaybeNext) {
1081       // FIXME this drops the error on the floor.
1082       consumeError(MaybeNext.takeError());
1083       return false;
1084     }
1085     Next = MaybeNext.get();
1086   }
1087
1088   return false;
1089 }
1090
1091 bool APINotesReader::Implementation::readObjCMethodBlock(
1092     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1093   if (Cursor.EnterSubBlock(OBJC_METHOD_BLOCK_ID))
1094     return true;
1095
1096   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1097   if (!MaybeNext) {
1098     // FIXME this drops the error on the floor.
1099     consumeError(MaybeNext.takeError());
1100     return false;
1101   }
1102   llvm::BitstreamEntry Next = MaybeNext.get();
1103   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1104     if (Next.Kind == llvm::BitstreamEntry::Error)
1105       return true;
1106
1107     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1108       // Unknown sub-block, possibly for use by a future version of the
1109       // API notes format.
1110       if (Cursor.SkipBlock())
1111         return true;
1112
1113       MaybeNext = Cursor.advance();
1114       if (!MaybeNext) {
1115         // FIXME this drops the error on the floor.
1116         consumeError(MaybeNext.takeError());
1117         return false;
1118       }
1119       Next = MaybeNext.get();
1120       continue;
1121     }
1122
1123     Scratch.clear();
1124     llvm::StringRef BlobData;
1125     llvm::Expected<unsigned> MaybeKind =
1126         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1127     if (!MaybeKind) {
1128       // FIXME this drops the error on the floor.
1129       consumeError(MaybeKind.takeError());
1130       return false;
1131     }
1132     unsigned Kind = MaybeKind.get();
1133     switch (Kind) {
1134     case objc_method_block::OBJC_METHOD_DATA: {
1135       // Already saw Objective-C method table.
1136       if (ObjCMethodTable)
1137         return true;
1138
1139       uint32_t tableOffset;
1140       objc_method_block::ObjCMethodDataLayout::readRecord(Scratch, tableOffset);
1141       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1142
1143       ObjCMethodTable.reset(SerializedObjCMethodTable::Create(
1144           base + tableOffset, base + sizeof(uint32_t), base));
1145       break;
1146     }
1147
1148     default:
1149       // Unknown record, possibly for use by a future version of the
1150       // module format.
1151       break;
1152     }
1153
1154     MaybeNext = Cursor.advance();
1155     if (!MaybeNext) {
1156       // FIXME this drops the error on the floor.
1157       consumeError(MaybeNext.takeError());
1158       return false;
1159     }
1160     Next = MaybeNext.get();
1161   }
1162
1163   return false;
1164 }
1165
1166 bool APINotesReader::Implementation::readObjCSelectorBlock(
1167     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1168   if (Cursor.EnterSubBlock(OBJC_SELECTOR_BLOCK_ID))
1169     return true;
1170
1171   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1172   if (!MaybeNext) {
1173     // FIXME this drops the error on the floor.
1174     consumeError(MaybeNext.takeError());
1175     return false;
1176   }
1177   llvm::BitstreamEntry Next = MaybeNext.get();
1178   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1179     if (Next.Kind == llvm::BitstreamEntry::Error)
1180       return true;
1181
1182     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1183       // Unknown sub-block, possibly for use by a future version of the
1184       // API notes format.
1185       if (Cursor.SkipBlock())
1186         return true;
1187
1188       MaybeNext = Cursor.advance();
1189       if (!MaybeNext) {
1190         // FIXME this drops the error on the floor.
1191         consumeError(MaybeNext.takeError());
1192         return false;
1193       }
1194       Next = MaybeNext.get();
1195       continue;
1196     }
1197
1198     Scratch.clear();
1199     llvm::StringRef BlobData;
1200     llvm::Expected<unsigned> MaybeKind =
1201         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1202     if (!MaybeKind) {
1203       // FIXME this drops the error on the floor.
1204       consumeError(MaybeKind.takeError());
1205       return false;
1206     }
1207     unsigned Kind = MaybeKind.get();
1208     switch (Kind) {
1209     case objc_selector_block::OBJC_SELECTOR_DATA: {
1210       // Already saw Objective-C selector table.
1211       if (ObjCSelectorTable)
1212         return true;
1213
1214       uint32_t tableOffset;
1215       objc_selector_block::ObjCSelectorDataLayout::readRecord(Scratch,
1216                                                               tableOffset);
1217       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1218
1219       ObjCSelectorTable.reset(SerializedObjCSelectorTable::Create(
1220           base + tableOffset, base + sizeof(uint32_t), base));
1221       break;
1222     }
1223
1224     default:
1225       // Unknown record, possibly for use by a future version of the
1226       // module format.
1227       break;
1228     }
1229
1230     MaybeNext = Cursor.advance();
1231     if (!MaybeNext) {
1232       // FIXME this drops the error on the floor.
1233       consumeError(MaybeNext.takeError());
1234       return false;
1235     }
1236     Next = MaybeNext.get();
1237   }
1238
1239   return false;
1240 }
1241
1242 bool APINotesReader::Implementation::readGlobalVariableBlock(
1243     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1244   if (Cursor.EnterSubBlock(GLOBAL_VARIABLE_BLOCK_ID))
1245     return true;
1246
1247   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1248   if (!MaybeNext) {
1249     // FIXME this drops the error on the floor.
1250     consumeError(MaybeNext.takeError());
1251     return false;
1252   }
1253   llvm::BitstreamEntry Next = MaybeNext.get();
1254   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1255     if (Next.Kind == llvm::BitstreamEntry::Error)
1256       return true;
1257
1258     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1259       // Unknown sub-block, possibly for use by a future version of the
1260       // API notes format.
1261       if (Cursor.SkipBlock())
1262         return true;
1263
1264       MaybeNext = Cursor.advance();
1265       if (!MaybeNext) {
1266         // FIXME this drops the error on the floor.
1267         consumeError(MaybeNext.takeError());
1268         return false;
1269       }
1270       Next = MaybeNext.get();
1271       continue;
1272     }
1273
1274     Scratch.clear();
1275     llvm::StringRef BlobData;
1276     llvm::Expected<unsigned> MaybeKind =
1277         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1278     if (!MaybeKind) {
1279       // FIXME this drops the error on the floor.
1280       consumeError(MaybeKind.takeError());
1281       return false;
1282     }
1283     unsigned Kind = MaybeKind.get();
1284     switch (Kind) {
1285     case global_variable_block::GLOBAL_VARIABLE_DATA: {
1286       // Already saw global variable table.
1287       if (GlobalVariableTable)
1288         return true;
1289
1290       uint32_t tableOffset;
1291       global_variable_block::GlobalVariableDataLayout::readRecord(Scratch,
1292                                                                   tableOffset);
1293       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1294
1295       GlobalVariableTable.reset(SerializedGlobalVariableTable::Create(
1296           base + tableOffset, base + sizeof(uint32_t), base));
1297       break;
1298     }
1299
1300     default:
1301       // Unknown record, possibly for use by a future version of the
1302       // module format.
1303       break;
1304     }
1305
1306     MaybeNext = Cursor.advance();
1307     if (!MaybeNext) {
1308       // FIXME this drops the error on the floor.
1309       consumeError(MaybeNext.takeError());
1310       return false;
1311     }
1312     Next = MaybeNext.get();
1313   }
1314
1315   return false;
1316 }
1317
1318 bool APINotesReader::Implementation::readGlobalFunctionBlock(
1319     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1320   if (Cursor.EnterSubBlock(GLOBAL_FUNCTION_BLOCK_ID))
1321     return true;
1322
1323   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1324   if (!MaybeNext) {
1325     // FIXME this drops the error on the floor.
1326     consumeError(MaybeNext.takeError());
1327     return false;
1328   }
1329   llvm::BitstreamEntry Next = MaybeNext.get();
1330   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1331     if (Next.Kind == llvm::BitstreamEntry::Error)
1332       return true;
1333
1334     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1335       // Unknown sub-block, possibly for use by a future version of the
1336       // API notes format.
1337       if (Cursor.SkipBlock())
1338         return true;
1339
1340       MaybeNext = Cursor.advance();
1341       if (!MaybeNext) {
1342         // FIXME this drops the error on the floor.
1343         consumeError(MaybeNext.takeError());
1344         return false;
1345       }
1346       Next = MaybeNext.get();
1347       continue;
1348     }
1349
1350     Scratch.clear();
1351     llvm::StringRef BlobData;
1352     llvm::Expected<unsigned> MaybeKind =
1353         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1354     if (!MaybeKind) {
1355       // FIXME this drops the error on the floor.
1356       consumeError(MaybeKind.takeError());
1357       return false;
1358     }
1359     unsigned Kind = MaybeKind.get();
1360     switch (Kind) {
1361     case global_function_block::GLOBAL_FUNCTION_DATA: {
1362       // Already saw global function table.
1363       if (GlobalFunctionTable)
1364         return true;
1365
1366       uint32_t tableOffset;
1367       global_function_block::GlobalFunctionDataLayout::readRecord(Scratch,
1368                                                                   tableOffset);
1369       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1370
1371       GlobalFunctionTable.reset(SerializedGlobalFunctionTable::Create(
1372           base + tableOffset, base + sizeof(uint32_t), base));
1373       break;
1374     }
1375
1376     default:
1377       // Unknown record, possibly for use by a future version of the
1378       // module format.
1379       break;
1380     }
1381
1382     MaybeNext = Cursor.advance();
1383     if (!MaybeNext) {
1384       // FIXME this drops the error on the floor.
1385       consumeError(MaybeNext.takeError());
1386       return false;
1387     }
1388     Next = MaybeNext.get();
1389   }
1390
1391   return false;
1392 }
1393
1394 bool APINotesReader::Implementation::readEnumConstantBlock(
1395     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1396   if (Cursor.EnterSubBlock(ENUM_CONSTANT_BLOCK_ID))
1397     return true;
1398
1399   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1400   if (!MaybeNext) {
1401     // FIXME this drops the error on the floor.
1402     consumeError(MaybeNext.takeError());
1403     return false;
1404   }
1405   llvm::BitstreamEntry Next = MaybeNext.get();
1406   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1407     if (Next.Kind == llvm::BitstreamEntry::Error)
1408       return true;
1409
1410     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1411       // Unknown sub-block, possibly for use by a future version of the
1412       // API notes format.
1413       if (Cursor.SkipBlock())
1414         return true;
1415
1416       MaybeNext = Cursor.advance();
1417       if (!MaybeNext) {
1418         // FIXME this drops the error on the floor.
1419         consumeError(MaybeNext.takeError());
1420         return false;
1421       }
1422       Next = MaybeNext.get();
1423       continue;
1424     }
1425
1426     Scratch.clear();
1427     llvm::StringRef BlobData;
1428     llvm::Expected<unsigned> MaybeKind =
1429         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1430     if (!MaybeKind) {
1431       // FIXME this drops the error on the floor.
1432       consumeError(MaybeKind.takeError());
1433       return false;
1434     }
1435     unsigned Kind = MaybeKind.get();
1436     switch (Kind) {
1437     case enum_constant_block::ENUM_CONSTANT_DATA: {
1438       // Already saw enumerator table.
1439       if (EnumConstantTable)
1440         return true;
1441
1442       uint32_t tableOffset;
1443       enum_constant_block::EnumConstantDataLayout::readRecord(Scratch,
1444                                                               tableOffset);
1445       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1446
1447       EnumConstantTable.reset(SerializedEnumConstantTable::Create(
1448           base + tableOffset, base + sizeof(uint32_t), base));
1449       break;
1450     }
1451
1452     default:
1453       // Unknown record, possibly for use by a future version of the
1454       // module format.
1455       break;
1456     }
1457
1458     MaybeNext = Cursor.advance();
1459     if (!MaybeNext) {
1460       // FIXME this drops the error on the floor.
1461       consumeError(MaybeNext.takeError());
1462       return false;
1463     }
1464     Next = MaybeNext.get();
1465   }
1466
1467   return false;
1468 }
1469
1470 bool APINotesReader::Implementation::readTagBlock(
1471     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1472   if (Cursor.EnterSubBlock(TAG_BLOCK_ID))
1473     return true;
1474
1475   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1476   if (!MaybeNext) {
1477     // FIXME this drops the error on the floor.
1478     consumeError(MaybeNext.takeError());
1479     return false;
1480   }
1481   llvm::BitstreamEntry Next = MaybeNext.get();
1482   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1483     if (Next.Kind == llvm::BitstreamEntry::Error)
1484       return true;
1485
1486     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1487       // Unknown sub-block, possibly for use by a future version of the
1488       // API notes format.
1489       if (Cursor.SkipBlock())
1490         return true;
1491
1492       MaybeNext = Cursor.advance();
1493       if (!MaybeNext) {
1494         // FIXME this drops the error on the floor.
1495         consumeError(MaybeNext.takeError());
1496         return false;
1497       }
1498       Next = MaybeNext.get();
1499       continue;
1500     }
1501
1502     Scratch.clear();
1503     llvm::StringRef BlobData;
1504     llvm::Expected<unsigned> MaybeKind =
1505         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1506     if (!MaybeKind) {
1507       // FIXME this drops the error on the floor.
1508       consumeError(MaybeKind.takeError());
1509       return false;
1510     }
1511     unsigned Kind = MaybeKind.get();
1512     switch (Kind) {
1513     case tag_block::TAG_DATA: {
1514       // Already saw tag table.
1515       if (TagTable)
1516         return true;
1517
1518       uint32_t tableOffset;
1519       tag_block::TagDataLayout::readRecord(Scratch, tableOffset);
1520       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1521
1522       TagTable.reset(SerializedTagTable::Create(base + tableOffset,
1523                                                 base + sizeof(uint32_t), base));
1524       break;
1525     }
1526
1527     default:
1528       // Unknown record, possibly for use by a future version of the
1529       // module format.
1530       break;
1531     }
1532
1533     MaybeNext = Cursor.advance();
1534     if (!MaybeNext) {
1535       // FIXME this drops the error on the floor.
1536       consumeError(MaybeNext.takeError());
1537       return false;
1538     }
1539     Next = MaybeNext.get();
1540   }
1541
1542   return false;
1543 }
1544
1545 bool APINotesReader::Implementation::readTypedefBlock(
1546     llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl<uint64_t> &Scratch) {
1547   if (Cursor.EnterSubBlock(TYPEDEF_BLOCK_ID))
1548     return true;
1549
1550   llvm::Expected<llvm::BitstreamEntry> MaybeNext = Cursor.advance();
1551   if (!MaybeNext) {
1552     // FIXME this drops the error on the floor.
1553     consumeError(MaybeNext.takeError());
1554     return false;
1555   }
1556   llvm::BitstreamEntry Next = MaybeNext.get();
1557   while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1558     if (Next.Kind == llvm::BitstreamEntry::Error)
1559       return true;
1560
1561     if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1562       // Unknown sub-block, possibly for use by a future version of the
1563       // API notes format.
1564       if (Cursor.SkipBlock())
1565         return true;
1566
1567       MaybeNext = Cursor.advance();
1568       if (!MaybeNext) {
1569         // FIXME this drops the error on the floor.
1570         consumeError(MaybeNext.takeError());
1571         return false;
1572       }
1573       Next = MaybeNext.get();
1574       continue;
1575     }
1576
1577     Scratch.clear();
1578     llvm::StringRef BlobData;
1579     llvm::Expected<unsigned> MaybeKind =
1580         Cursor.readRecord(Next.ID, Scratch, &BlobData);
1581     if (!MaybeKind) {
1582       // FIXME this drops the error on the floor.
1583       consumeError(MaybeKind.takeError());
1584       return false;
1585     }
1586     unsigned Kind = MaybeKind.get();
1587     switch (Kind) {
1588     case typedef_block::TYPEDEF_DATA: {
1589       // Already saw typedef table.
1590       if (TypedefTable)
1591         return true;
1592
1593       uint32_t tableOffset;
1594       typedef_block::TypedefDataLayout::readRecord(Scratch, tableOffset);
1595       auto base = reinterpret_cast<const uint8_t *>(BlobData.data());
1596
1597       TypedefTable.reset(SerializedTypedefTable::Create(
1598           base + tableOffset, base + sizeof(uint32_t), base));
1599       break;
1600     }
1601
1602     default:
1603       // Unknown record, possibly for use by a future version of the
1604       // module format.
1605       break;
1606     }
1607
1608     MaybeNext = Cursor.advance();
1609     if (!MaybeNext) {
1610       // FIXME this drops the error on the floor.
1611       consumeError(MaybeNext.takeError());
1612       return false;
1613     }
1614     Next = MaybeNext.get();
1615   }
1616
1617   return false;
1618 }
1619
1620 APINotesReader::APINotesReader(llvm::MemoryBuffer *InputBuffer,
1621                                llvm::VersionTuple SwiftVersion, bool &Failed)
1622     : Implementation(new class Implementation) {
1623   Failed = false;
1624
1625   // Initialize the input buffer.
1626   Implementation->InputBuffer = InputBuffer;
1627   Implementation->SwiftVersion = SwiftVersion;
1628   llvm::BitstreamCursor Cursor(*Implementation->InputBuffer);
1629
1630   // Validate signature.
1631   for (auto byte : API_NOTES_SIGNATURE) {
1632     if (Cursor.AtEndOfStream()) {
1633       Failed = true;
1634       return;
1635     }
1636     if (llvm::Expected<llvm::SimpleBitstreamCursor::word_t> maybeRead =
1637             Cursor.Read(8)) {
1638       if (maybeRead.get() != byte) {
1639         Failed = true;
1640         return;
1641       }
1642     } else {
1643       // FIXME this drops the error on the floor.
1644       consumeError(maybeRead.takeError());
1645       Failed = true;
1646       return;
1647     }
1648   }
1649
1650   // Look at all of the blocks.
1651   bool HasValidControlBlock = false;
1652   llvm::SmallVector<uint64_t, 64> Scratch;
1653   while (!Cursor.AtEndOfStream()) {
1654     llvm::Expected<llvm::BitstreamEntry> MaybeTopLevelEntry = Cursor.advance();
1655     if (!MaybeTopLevelEntry) {
1656       // FIXME this drops the error on the floor.
1657       consumeError(MaybeTopLevelEntry.takeError());
1658       Failed = true;
1659       return;
1660     }
1661     llvm::BitstreamEntry TopLevelEntry = MaybeTopLevelEntry.get();
1662
1663     if (TopLevelEntry.Kind != llvm::BitstreamEntry::SubBlock)
1664       break;
1665
1666     switch (TopLevelEntry.ID) {
1667     case llvm::bitc::BLOCKINFO_BLOCK_ID:
1668       if (!Cursor.ReadBlockInfoBlock()) {
1669         Failed = true;
1670         break;
1671       }
1672       break;
1673
1674     case CONTROL_BLOCK_ID:
1675       // Only allow a single control block.
1676       if (HasValidControlBlock ||
1677           Implementation->readControlBlock(Cursor, Scratch)) {
1678         Failed = true;
1679         return;
1680       }
1681
1682       HasValidControlBlock = true;
1683       break;
1684
1685     case IDENTIFIER_BLOCK_ID:
1686       if (!HasValidControlBlock ||
1687           Implementation->readIdentifierBlock(Cursor, Scratch)) {
1688         Failed = true;
1689         return;
1690       }
1691       break;
1692
1693     case OBJC_CONTEXT_BLOCK_ID:
1694       if (!HasValidControlBlock ||
1695           Implementation->readObjCContextBlock(Cursor, Scratch)) {
1696         Failed = true;
1697         return;
1698       }
1699
1700       break;
1701
1702     case OBJC_PROPERTY_BLOCK_ID:
1703       if (!HasValidControlBlock ||
1704           Implementation->readObjCPropertyBlock(Cursor, Scratch)) {
1705         Failed = true;
1706         return;
1707       }
1708       break;
1709
1710     case OBJC_METHOD_BLOCK_ID:
1711       if (!HasValidControlBlock ||
1712           Implementation->readObjCMethodBlock(Cursor, Scratch)) {
1713         Failed = true;
1714         return;
1715       }
1716       break;
1717
1718     case OBJC_SELECTOR_BLOCK_ID:
1719       if (!HasValidControlBlock ||
1720           Implementation->readObjCSelectorBlock(Cursor, Scratch)) {
1721         Failed = true;
1722         return;
1723       }
1724       break;
1725
1726     case GLOBAL_VARIABLE_BLOCK_ID:
1727       if (!HasValidControlBlock ||
1728           Implementation->readGlobalVariableBlock(Cursor, Scratch)) {
1729         Failed = true;
1730         return;
1731       }
1732       break;
1733
1734     case GLOBAL_FUNCTION_BLOCK_ID:
1735       if (!HasValidControlBlock ||
1736           Implementation->readGlobalFunctionBlock(Cursor, Scratch)) {
1737         Failed = true;
1738         return;
1739       }
1740       break;
1741
1742     case ENUM_CONSTANT_BLOCK_ID:
1743       if (!HasValidControlBlock ||
1744           Implementation->readEnumConstantBlock(Cursor, Scratch)) {
1745         Failed = true;
1746         return;
1747       }
1748       break;
1749
1750     case TAG_BLOCK_ID:
1751       if (!HasValidControlBlock ||
1752           Implementation->readTagBlock(Cursor, Scratch)) {
1753         Failed = true;
1754         return;
1755       }
1756       break;
1757
1758     case TYPEDEF_BLOCK_ID:
1759       if (!HasValidControlBlock ||
1760           Implementation->readTypedefBlock(Cursor, Scratch)) {
1761         Failed = true;
1762         return;
1763       }
1764       break;
1765
1766     default:
1767       // Unknown top-level block, possibly for use by a future version of the
1768       // module format.
1769       if (Cursor.SkipBlock()) {
1770         Failed = true;
1771         return;
1772       }
1773       break;
1774     }
1775   }
1776
1777   if (!Cursor.AtEndOfStream()) {
1778     Failed = true;
1779     return;
1780   }
1781 }
1782
1783 APINotesReader::~APINotesReader() { delete Implementation->InputBuffer; }
1784
1785 std::unique_ptr<APINotesReader>
1786 APINotesReader::Create(std::unique_ptr<llvm::MemoryBuffer> InputBuffer,
1787                        llvm::VersionTuple SwiftVersion) {
1788   bool Failed = false;
1789   std::unique_ptr<APINotesReader> Reader(
1790       new APINotesReader(InputBuffer.release(), SwiftVersion, Failed));
1791   if (Failed)
1792     return nullptr;
1793
1794   return Reader;
1795 }
1796
1797 template <typename T>
1798 APINotesReader::VersionedInfo<T>::VersionedInfo(
1799     llvm::VersionTuple Version,
1800     llvm::SmallVector<std::pair<llvm::VersionTuple, T>, 1> Results)
1801     : Results(std::move(Results)) {
1802
1803   assert(!Results.empty());
1804   assert(std::is_sorted(
1805       Results.begin(), Results.end(),
1806       [](const std::pair<llvm::VersionTuple, T> &left,
1807          const std::pair<llvm::VersionTuple, T> &right) -> bool {
1808         assert(left.first != right.first && "two entries for the same version");
1809         return left.first < right.first;
1810       }));
1811
1812   Selected = std::nullopt;
1813   for (unsigned i = 0, n = Results.size(); i != n; ++i) {
1814     if (!Version.empty() && Results[i].first >= Version) {
1815       // If the current version is "4", then entries for 4 are better than
1816       // entries for 5, but both are valid. Because entries are sorted, we get
1817       // that behavior by picking the first match.
1818       Selected = i;
1819       break;
1820     }
1821   }
1822
1823   // If we didn't find a match but we have an unversioned result, use the
1824   // unversioned result. This will always be the first entry because we encode
1825   // it as version 0.
1826   if (!Selected && Results[0].first.empty())
1827     Selected = 0;
1828 }
1829
1830 auto APINotesReader::lookupObjCClassID(llvm::StringRef Name)
1831     -> std::optional<ContextID> {
1832   if (!Implementation->ObjCContextIDTable)
1833     return std::nullopt;
1834
1835   std::optional<IdentifierID> ClassID = Implementation->getIdentifier(Name);
1836   if (!ClassID)
1837     return std::nullopt;
1838
1839   // ObjC classes can't be declared in C++ namespaces, so use -1 as the global
1840   // context.
1841   auto KnownID = Implementation->ObjCContextIDTable->find(
1842       ContextTableKey(-1, (uint8_t)ContextKind::ObjCClass, *ClassID));
1843   if (KnownID == Implementation->ObjCContextIDTable->end())
1844     return std::nullopt;
1845
1846   return ContextID(*KnownID);
1847 }
1848
1849 auto APINotesReader::lookupObjCClassInfo(llvm::StringRef Name)
1850     -> VersionedInfo<ObjCContextInfo> {
1851   if (!Implementation->ObjCContextInfoTable)
1852     return std::nullopt;
1853
1854   std::optional<ContextID> CtxID = lookupObjCClassID(Name);
1855   if (!CtxID)
1856     return std::nullopt;
1857
1858   auto KnownInfo = Implementation->ObjCContextInfoTable->find(CtxID->Value);
1859   if (KnownInfo == Implementation->ObjCContextInfoTable->end())
1860     return std::nullopt;
1861
1862   return {Implementation->SwiftVersion, *KnownInfo};
1863 }
1864
1865 auto APINotesReader::lookupObjCProtocolID(llvm::StringRef Name)
1866     -> std::optional<ContextID> {
1867   if (!Implementation->ObjCContextIDTable)
1868     return std::nullopt;
1869
1870   std::optional<IdentifierID> classID = Implementation->getIdentifier(Name);
1871   if (!classID)
1872     return std::nullopt;
1873
1874   // ObjC classes can't be declared in C++ namespaces, so use -1 as the global
1875   // context.
1876   auto KnownID = Implementation->ObjCContextIDTable->find(
1877       ContextTableKey(-1, (uint8_t)ContextKind::ObjCProtocol, *classID));
1878   if (KnownID == Implementation->ObjCContextIDTable->end())
1879     return std::nullopt;
1880
1881   return ContextID(*KnownID);
1882 }
1883
1884 auto APINotesReader::lookupObjCProtocolInfo(llvm::StringRef Name)
1885     -> VersionedInfo<ObjCContextInfo> {
1886   if (!Implementation->ObjCContextInfoTable)
1887     return std::nullopt;
1888
1889   std::optional<ContextID> CtxID = lookupObjCProtocolID(Name);
1890   if (!CtxID)
1891     return std::nullopt;
1892
1893   auto KnownInfo = Implementation->ObjCContextInfoTable->find(CtxID->Value);
1894   if (KnownInfo == Implementation->ObjCContextInfoTable->end())
1895     return std::nullopt;
1896
1897   return {Implementation->SwiftVersion, *KnownInfo};
1898 }
1899
1900 auto APINotesReader::lookupObjCProperty(ContextID CtxID, llvm::StringRef Name,
1901                                         bool IsInstance)
1902     -> VersionedInfo<ObjCPropertyInfo> {
1903   if (!Implementation->ObjCPropertyTable)
1904     return std::nullopt;
1905
1906   std::optional<IdentifierID> PropertyID = Implementation->getIdentifier(Name);
1907   if (!PropertyID)
1908     return std::nullopt;
1909
1910   auto Known = Implementation->ObjCPropertyTable->find(
1911       std::make_tuple(CtxID.Value, *PropertyID, (char)IsInstance));
1912   if (Known == Implementation->ObjCPropertyTable->end())
1913     return std::nullopt;
1914
1915   return {Implementation->SwiftVersion, *Known};
1916 }
1917
1918 auto APINotesReader::lookupObjCMethod(ContextID CtxID, ObjCSelectorRef Selector,
1919                                       bool IsInstanceMethod)
1920     -> VersionedInfo<ObjCMethodInfo> {
1921   if (!Implementation->ObjCMethodTable)
1922     return std::nullopt;
1923
1924   std::optional<SelectorID> SelID = Implementation->getSelector(Selector);
1925   if (!SelID)
1926     return std::nullopt;
1927
1928   auto Known = Implementation->ObjCMethodTable->find(
1929       ObjCMethodTableInfo::internal_key_type{CtxID.Value, *SelID,
1930                                              IsInstanceMethod});
1931   if (Known == Implementation->ObjCMethodTable->end())
1932     return std::nullopt;
1933
1934   return {Implementation->SwiftVersion, *Known};
1935 }
1936
1937 auto APINotesReader::lookupGlobalVariable(llvm::StringRef Name,
1938                                           std::optional<Context> Ctx)
1939     -> VersionedInfo<GlobalVariableInfo> {
1940   if (!Implementation->GlobalVariableTable)
1941     return std::nullopt;
1942
1943   std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
1944   if (!NameID)
1945     return std::nullopt;
1946
1947   ContextTableKey Key(Ctx, *NameID);
1948
1949   auto Known = Implementation->GlobalVariableTable->find(Key);
1950   if (Known == Implementation->GlobalVariableTable->end())
1951     return std::nullopt;
1952
1953   return {Implementation->SwiftVersion, *Known};
1954 }
1955
1956 auto APINotesReader::lookupGlobalFunction(llvm::StringRef Name,
1957                                           std::optional<Context> Ctx)
1958     -> VersionedInfo<GlobalFunctionInfo> {
1959   if (!Implementation->GlobalFunctionTable)
1960     return std::nullopt;
1961
1962   std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
1963   if (!NameID)
1964     return std::nullopt;
1965
1966   ContextTableKey Key(Ctx, *NameID);
1967
1968   auto Known = Implementation->GlobalFunctionTable->find(Key);
1969   if (Known == Implementation->GlobalFunctionTable->end())
1970     return std::nullopt;
1971
1972   return {Implementation->SwiftVersion, *Known};
1973 }
1974
1975 auto APINotesReader::lookupEnumConstant(llvm::StringRef Name)
1976     -> VersionedInfo<EnumConstantInfo> {
1977   if (!Implementation->EnumConstantTable)
1978     return std::nullopt;
1979
1980   std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
1981   if (!NameID)
1982     return std::nullopt;
1983
1984   auto Known = Implementation->EnumConstantTable->find(*NameID);
1985   if (Known == Implementation->EnumConstantTable->end())
1986     return std::nullopt;
1987
1988   return {Implementation->SwiftVersion, *Known};
1989 }
1990
1991 auto APINotesReader::lookupTag(llvm::StringRef Name, std::optional<Context> Ctx)
1992     -> VersionedInfo<TagInfo> {
1993   if (!Implementation->TagTable)
1994     return std::nullopt;
1995
1996   std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
1997   if (!NameID)
1998     return std::nullopt;
1999
2000   ContextTableKey Key(Ctx, *NameID);
2001
2002   auto Known = Implementation->TagTable->find(Key);
2003   if (Known == Implementation->TagTable->end())
2004     return std::nullopt;
2005
2006   return {Implementation->SwiftVersion, *Known};
2007 }
2008
2009 auto APINotesReader::lookupTypedef(llvm::StringRef Name,
2010                                    std::optional<Context> Ctx)
2011     -> VersionedInfo<TypedefInfo> {
2012   if (!Implementation->TypedefTable)
2013     return std::nullopt;
2014
2015   std::optional<IdentifierID> NameID = Implementation->getIdentifier(Name);
2016   if (!NameID)
2017     return std::nullopt;
2018
2019   ContextTableKey Key(Ctx, *NameID);
2020
2021   auto Known = Implementation->TypedefTable->find(Key);
2022   if (Known == Implementation->TypedefTable->end())
2023     return std::nullopt;
2024
2025   return {Implementation->SwiftVersion, *Known};
2026 }
2027
2028 auto APINotesReader::lookupNamespaceID(
2029     llvm::StringRef Name, std::optional<ContextID> ParentNamespaceID)
2030     -> std::optional<ContextID> {
2031   if (!Implementation->ObjCContextIDTable)
2032     return std::nullopt;
2033
2034   std::optional<IdentifierID> NamespaceID = Implementation->getIdentifier(Name);
2035   if (!NamespaceID)
2036     return std::nullopt;
2037
2038   uint32_t RawParentNamespaceID =
2039       ParentNamespaceID ? ParentNamespaceID->Value : -1;
2040   auto KnownID = Implementation->ObjCContextIDTable->find(
2041       {RawParentNamespaceID, (uint8_t)ContextKind::Namespace, *NamespaceID});
2042   if (KnownID == Implementation->ObjCContextIDTable->end())
2043     return std::nullopt;
2044
2045   return ContextID(*KnownID);
2046 }
2047
2048 } // namespace api_notes
2049 } // namespace clang