18#include "llvm/ADT/Hashing.h"
19#include "llvm/Bitstream/BitstreamReader.h"
20#include "llvm/Support/DJB.h"
21#include "llvm/Support/OnDiskHashTable.h"
25using namespace llvm::support;
29llvm::VersionTuple ReadVersionTuple(
const uint8_t *&
Data) {
30 uint8_t NumVersions = (*
Data++) & 0x03;
32 unsigned Major = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
34 return llvm::VersionTuple(Major);
36 unsigned Minor = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
38 return llvm::VersionTuple(Major, Minor);
41 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
43 return llvm::VersionTuple(Major, Minor, Subminor);
45 unsigned Build = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
46 return llvm::VersionTuple(Major, Minor, Subminor, Build);
50template <
typename Derived,
typename KeyType,
typename UnversionedDataType>
51class VersionedTableInfo {
53 using internal_key_type = KeyType;
54 using external_key_type = KeyType;
56 llvm::SmallVector<std::pair<llvm::VersionTuple, UnversionedDataType>, 1>;
57 using hash_value_type =
size_t;
58 using offset_type = unsigned;
60 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
62 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
64 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
68 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
70 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
72 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
73 return {KeyLength, DataLength};
76 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
78 unsigned NumElements =
79 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
81 Result.reserve(NumElements);
82 for (
unsigned i = 0; i != NumElements; ++i) {
83 auto version = ReadVersionTuple(
Data);
84 const auto *DataBefore =
Data;
86 auto UnversionedData = Derived::readUnversioned(Key,
Data);
87 assert(
Data != DataBefore &&
88 "Unversioned data reader didn't move pointer");
89 Result.push_back({version, UnversionedData});
97 uint8_t EncodedBits = *
Data++;
98 Info.Unavailable = (EncodedBits >> 1) & 0x01;
99 Info.UnavailableInSwift = EncodedBits & 0x01;
100 if ((EncodedBits >> 2) & 0x01)
101 Info.setSwiftPrivate(
static_cast<bool>((EncodedBits >> 3) & 0x01));
102 if ((EncodedBits >> 4) & 0x01)
107 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
108 Info.UnavailableMsg =
109 std::string(
reinterpret_cast<const char *
>(
Data),
110 reinterpret_cast<const char *
>(
Data) + MsgLength);
113 unsigned SwiftNameLength =
114 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
116 std::string(
reinterpret_cast<const char *
>(
Data),
117 reinterpret_cast<const char *
>(
Data) + SwiftNameLength);
118 Data += SwiftNameLength;
123 ReadCommonEntityInfo(
Data, Info);
125 unsigned SwiftBridgeLength =
126 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
127 if (SwiftBridgeLength > 0) {
128 Info.setSwiftBridge(std::string(
reinterpret_cast<const char *
>(
Data),
129 SwiftBridgeLength - 1));
130 Data += SwiftBridgeLength - 1;
133 unsigned ErrorDomainLength =
134 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
135 if (ErrorDomainLength > 0) {
136 Info.setNSErrorDomain(std::optional<std::string>(std::string(
137 reinterpret_cast<const char *
>(
Data), ErrorDomainLength - 1)));
138 Data += ErrorDomainLength - 1;
141 if (
unsigned ConformanceLength =
142 endian::readNext<uint16_t, llvm::endianness::little>(
Data)) {
143 Info.setSwiftConformance(std::string(
reinterpret_cast<const char *
>(
Data),
144 ConformanceLength - 1));
145 Data += ConformanceLength - 1;
150class IdentifierTableInfo {
152 using internal_key_type = llvm::StringRef;
153 using external_key_type = llvm::StringRef;
156 using offset_type = unsigned;
158 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
160 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
162 hash_value_type
ComputeHash(internal_key_type Key) {
163 return llvm::djbHash(Key);
166 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
170 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
172 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
173 unsigned DataLength =
174 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
175 return {KeyLength, DataLength};
178 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
179 return llvm::StringRef(
reinterpret_cast<const char *
>(
Data), Length);
182 static data_type ReadData(internal_key_type key,
const uint8_t *
Data,
184 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
190class ContextIDTableInfo {
192 using internal_key_type = ContextTableKey;
193 using external_key_type = internal_key_type;
194 using data_type = unsigned;
195 using hash_value_type =
size_t;
196 using offset_type = unsigned;
198 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
200 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
202 hash_value_type
ComputeHash(internal_key_type Key) {
203 return static_cast<size_t>(Key.hashValue());
206 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
210 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
212 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
213 unsigned DataLength =
214 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
215 return {KeyLength, DataLength};
218 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
220 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
222 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
223 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
227 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
229 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
234class ContextInfoTableInfo
235 :
public VersionedTableInfo<ContextInfoTableInfo, unsigned, ContextInfo> {
237 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
238 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
241 hash_value_type
ComputeHash(internal_key_type Key) {
245 static ContextInfo readUnversioned(internal_key_type Key,
246 const uint8_t *&
Data) {
248 ReadCommonTypeInfo(
Data, Info);
249 uint8_t Payload = *
Data++;
252 Info.setHasDesignatedInits(
true);
253 Payload = Payload >> 1;
256 Info.setDefaultNullability(
static_cast<NullabilityKind>(Payload & 0x03));
259 if (Payload & (1 << 1))
260 Info.setSwiftObjCMembers(Payload & 1);
263 if (Payload & (1 << 1))
264 Info.setSwiftImportAsNonGeneric(Payload & 1);
272 ReadCommonEntityInfo(
Data, Info);
278 auto TypeLen = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
279 Info.setType(std::string(
Data,
Data + TypeLen));
284class ObjCPropertyTableInfo
285 :
public VersionedTableInfo<ObjCPropertyTableInfo,
286 std::tuple<uint32_t, uint32_t, uint8_t>,
289 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
290 auto ClassID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
291 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
292 char IsInstance = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
293 return {ClassID, NameID, IsInstance};
296 hash_value_type
ComputeHash(internal_key_type Key) {
300 static ObjCPropertyInfo readUnversioned(internal_key_type Key,
301 const uint8_t *&
Data) {
302 ObjCPropertyInfo Info;
303 ReadVariableInfo(
Data, Info);
304 uint8_t Flags = *
Data++;
305 if (Flags & (1 << 0))
306 Info.setSwiftImportAsAccessors(Flags & (1 << 1));
313 :
public VersionedTableInfo<FieldTableInfo, SingleDeclTableKey, FieldInfo> {
315 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
316 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
317 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
318 return {CtxID, NameID};
321 hash_value_type
ComputeHash(internal_key_type Key) {
322 return static_cast<size_t>(Key.hashValue());
325 static FieldInfo readUnversioned(internal_key_type Key,
326 const uint8_t *&
Data) {
328 ReadVariableInfo(
Data, Info);
335 ReadVariableInfo(
Data, Info);
337 uint8_t Payload = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
338 if (
auto RawConvention = Payload & 0x7) {
340 Info.setRetainCountConvention(Convention);
344 Info.setLifetimebound(Payload & 0x02);
347 Info.setNoEscape(Payload & 0x02);
349 assert(Payload == 0 &&
"Bad API notes");
354 ReadCommonEntityInfo(
Data, Info);
356 uint8_t Payload = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
357 if (
auto RawConvention = Payload & 0x7) {
359 Info.setRetainCountConvention(Convention);
362 Info.NullabilityAudited = Payload & 0x1;
364 assert(Payload == 0 &&
"Bad API notes");
366 Info.NumAdjustedNullable =
367 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
368 Info.NullabilityPayload =
369 endian::readNext<uint64_t, llvm::endianness::little>(
Data);
372 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
373 while (NumParams > 0) {
375 ReadParamInfo(
Data, pi);
376 Info.Params.push_back(pi);
380 unsigned ResultTypeLen =
381 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
382 Info.ResultType = std::string(
Data,
Data + ResultTypeLen);
383 Data += ResultTypeLen;
385 unsigned SwiftReturnOwnershipLength =
386 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
387 Info.SwiftReturnOwnership = std::string(
reinterpret_cast<const char *
>(
Data),
388 reinterpret_cast<const char *
>(
Data) +
389 SwiftReturnOwnershipLength);
390 Data += SwiftReturnOwnershipLength;
394class ObjCMethodTableInfo
395 :
public VersionedTableInfo<ObjCMethodTableInfo,
396 std::tuple<uint32_t, uint32_t, uint8_t>,
399 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
400 auto ClassID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
402 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
403 auto IsInstance = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
407 hash_value_type
ComputeHash(internal_key_type Key) {
411 static ObjCMethodInfo readUnversioned(internal_key_type Key,
412 const uint8_t *&
Data) {
414 uint8_t Payload = *
Data++;
415 bool HasSelf = Payload & 0x01;
417 Info.RequiredInit = Payload & 0x01;
419 Info.DesignatedInit = Payload & 0x01;
421 assert(Payload == 0 &&
"Unable to fully decode 'Payload'.");
423 ReadFunctionInfo(
Data, Info);
425 Info.Self = ParamInfo{};
426 ReadParamInfo(
Data, *Info.Self);
433class ObjCSelectorTableInfo {
435 using internal_key_type = StoredObjCSelector;
436 using external_key_type = internal_key_type;
438 using hash_value_type = unsigned;
439 using offset_type = unsigned;
441 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
443 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
445 hash_value_type
ComputeHash(internal_key_type Key) {
446 return llvm::DenseMapInfo<StoredObjCSelector>::getHashValue(Key);
449 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
450 return llvm::DenseMapInfo<StoredObjCSelector>::isEqual(LHS, RHS);
453 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
455 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
456 unsigned DataLength =
457 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
458 return {KeyLength, DataLength};
461 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
462 internal_key_type Key;
463 Key.NumArgs = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
464 unsigned NumIdents = (Length -
sizeof(uint16_t)) /
sizeof(uint32_t);
465 for (
unsigned i = 0; i != NumIdents; ++i) {
466 Key.Identifiers.push_back(
467 endian::readNext<uint32_t, llvm::endianness::little>(
Data));
472 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
474 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
479class GlobalVariableTableInfo
480 :
public VersionedTableInfo<GlobalVariableTableInfo, SingleDeclTableKey,
481 GlobalVariableInfo> {
483 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
484 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
485 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
486 return {CtxID, NameID};
489 hash_value_type
ComputeHash(internal_key_type Key) {
490 return static_cast<size_t>(Key.hashValue());
493 static GlobalVariableInfo readUnversioned(internal_key_type Key,
494 const uint8_t *&
Data) {
495 GlobalVariableInfo Info;
496 ReadVariableInfo(
Data, Info);
502class GlobalFunctionTableInfo
503 :
public VersionedTableInfo<GlobalFunctionTableInfo, SingleDeclTableKey,
504 GlobalFunctionInfo> {
506 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
507 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
508 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
509 return {CtxID, NameID};
512 hash_value_type
ComputeHash(internal_key_type Key) {
513 return static_cast<size_t>(Key.hashValue());
516 static GlobalFunctionInfo readUnversioned(internal_key_type Key,
517 const uint8_t *&
Data) {
518 GlobalFunctionInfo Info;
519 ReadFunctionInfo(
Data, Info);
525class CXXMethodTableInfo
526 :
public VersionedTableInfo<CXXMethodTableInfo, SingleDeclTableKey,
529 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
530 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
531 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
532 return {CtxID, NameID};
535 hash_value_type
ComputeHash(internal_key_type Key) {
536 return static_cast<size_t>(Key.hashValue());
539 static CXXMethodInfo readUnversioned(internal_key_type Key,
540 const uint8_t *&
Data) {
543 uint8_t Payload = *
Data++;
544 bool HasThis = Payload & 0x01;
546 assert(Payload == 0 &&
"Unable to fully decode 'Payload'.");
548 ReadFunctionInfo(
Data, Info);
550 Info.This = ParamInfo{};
551 ReadParamInfo(
Data, *Info.This);
558class EnumConstantTableInfo
559 :
public VersionedTableInfo<EnumConstantTableInfo, uint32_t,
562 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
563 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
567 hash_value_type
ComputeHash(internal_key_type Key) {
571 static EnumConstantInfo readUnversioned(internal_key_type Key,
572 const uint8_t *&
Data) {
573 EnumConstantInfo Info;
574 ReadCommonEntityInfo(
Data, Info);
581 :
public VersionedTableInfo<TagTableInfo, SingleDeclTableKey, TagInfo> {
583 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
584 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
586 endian::readNext<IdentifierID, llvm::endianness::little>(
Data);
587 return {CtxID, NameID};
590 hash_value_type
ComputeHash(internal_key_type Key) {
591 return static_cast<size_t>(Key.hashValue());
594 static TagInfo readUnversioned(internal_key_type Key,
const uint8_t *&
Data) {
597 uint8_t Payload = *
Data++;
599 Info.setFlagEnum(Payload & 2);
602 Info.EnumExtensibility =
606 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
610 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
612 Info.setSwiftEscapable(std::optional(Escapable ==
kSwiftConforms));
614 unsigned ImportAsLength =
615 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
616 if (ImportAsLength > 0) {
618 std::string(
reinterpret_cast<const char *
>(
Data), ImportAsLength - 1);
619 Data += ImportAsLength - 1;
621 unsigned RetainOpLength =
622 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
623 if (RetainOpLength > 0) {
625 std::string(
reinterpret_cast<const char *
>(
Data), RetainOpLength - 1);
626 Data += RetainOpLength - 1;
628 unsigned ReleaseOpLength =
629 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
630 if (ReleaseOpLength > 0) {
631 Info.SwiftReleaseOp = std::string(
reinterpret_cast<const char *
>(
Data),
632 ReleaseOpLength - 1);
633 Data += ReleaseOpLength - 1;
635 unsigned DefaultOwnershipLength =
636 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
637 if (DefaultOwnershipLength > 0) {
638 Info.SwiftDefaultOwnership = std::string(
639 reinterpret_cast<const char *
>(
Data), DefaultOwnershipLength - 1);
640 Data += DefaultOwnershipLength - 1;
642 unsigned DestroyOpLength =
643 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
644 if (DestroyOpLength > 0) {
645 Info.SwiftDestroyOp = std::string(
reinterpret_cast<const char *
>(
Data),
646 DestroyOpLength - 1);
647 Data += DestroyOpLength - 1;
650 ReadCommonTypeInfo(
Data, Info);
656class TypedefTableInfo
657 :
public VersionedTableInfo<TypedefTableInfo, SingleDeclTableKey,
660 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
661 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
663 endian::readNext<IdentifierID, llvm::endianness::little>(
Data);
664 return {CtxID, nameID};
667 hash_value_type
ComputeHash(internal_key_type Key) {
668 return static_cast<size_t>(Key.hashValue());
671 static TypedefInfo readUnversioned(internal_key_type Key,
672 const uint8_t *&
Data) {
675 uint8_t Payload = *
Data++;
679 ReadCommonTypeInfo(
Data, Info);
701 llvm::OnDiskIterableChainedHashTable<IdentifierTableInfo>;
707 llvm::OnDiskIterableChainedHashTable<ContextIDTableInfo>;
713 llvm::OnDiskIterableChainedHashTable<ContextInfoTableInfo>;
719 llvm::OnDiskIterableChainedHashTable<ObjCPropertyTableInfo>;
725 llvm::OnDiskIterableChainedHashTable<FieldTableInfo>;
731 llvm::OnDiskIterableChainedHashTable<ObjCMethodTableInfo>;
737 llvm::OnDiskIterableChainedHashTable<CXXMethodTableInfo>;
743 llvm::OnDiskIterableChainedHashTable<ObjCSelectorTableInfo>;
749 llvm::OnDiskIterableChainedHashTable<GlobalVariableTableInfo>;
755 llvm::OnDiskIterableChainedHashTable<GlobalFunctionTableInfo>;
761 llvm::OnDiskIterableChainedHashTable<EnumConstantTableInfo>;
772 llvm::OnDiskIterableChainedHashTable<TypedefTableInfo>;
779 std::optional<IdentifierID>
getIdentifier(llvm::StringRef Str);
813std::optional<IdentifierID>
828std::optional<SelectorID>
836 for (
auto Ident :
Selector.Identifiers) {
856 bool SawMetadata =
false;
861 consumeError(MaybeNext.takeError());
864 llvm::BitstreamEntry
Next = MaybeNext.get();
866 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
867 if (
Next.Kind == llvm::BitstreamEntry::Error)
870 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
873 if (Cursor.SkipBlock())
876 MaybeNext = Cursor.advance();
879 consumeError(MaybeNext.takeError());
882 Next = MaybeNext.get();
887 llvm::StringRef BlobData;
889 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
892 consumeError(MaybeKind.takeError());
895 unsigned Kind = MaybeKind.get();
926 MaybeNext = Cursor.advance();
929 consumeError(MaybeNext.takeError());
932 Next = MaybeNext.get();
946 consumeError(MaybeNext.takeError());
949 llvm::BitstreamEntry
Next = MaybeNext.get();
951 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
952 if (
Next.Kind == llvm::BitstreamEntry::Error)
955 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
958 if (Cursor.SkipBlock())
961 MaybeNext = Cursor.advance();
964 consumeError(MaybeNext.takeError());
967 Next = MaybeNext.get();
972 llvm::StringRef BlobData;
974 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
977 consumeError(MaybeKind.takeError());
980 unsigned Kind = MaybeKind.get();
987 uint32_t tableOffset;
988 identifier_block::IdentifierDataLayout::readRecord(Scratch, tableOffset);
989 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
992 base + tableOffset, base +
sizeof(uint32_t), base));
1002 MaybeNext = Cursor.advance();
1005 consumeError(MaybeNext.takeError());
1008 Next = MaybeNext.get();
1022 consumeError(MaybeNext.takeError());
1025 llvm::BitstreamEntry
Next = MaybeNext.get();
1027 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1028 if (
Next.Kind == llvm::BitstreamEntry::Error)
1031 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1034 if (Cursor.SkipBlock())
1037 MaybeNext = Cursor.advance();
1040 consumeError(MaybeNext.takeError());
1043 Next = MaybeNext.get();
1048 llvm::StringRef BlobData;
1050 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1053 consumeError(MaybeKind.takeError());
1056 unsigned Kind = MaybeKind.get();
1063 uint32_t tableOffset;
1064 context_block::ContextIDLayout::readRecord(Scratch, tableOffset);
1065 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1068 base + tableOffset, base +
sizeof(uint32_t), base));
1077 uint32_t tableOffset;
1078 context_block::ContextInfoLayout::readRecord(Scratch, tableOffset);
1079 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1082 base + tableOffset, base +
sizeof(uint32_t), base));
1092 MaybeNext = Cursor.advance();
1095 consumeError(MaybeNext.takeError());
1098 Next = MaybeNext.get();
1112 consumeError(MaybeNext.takeError());
1115 llvm::BitstreamEntry
Next = MaybeNext.get();
1117 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1118 if (
Next.Kind == llvm::BitstreamEntry::Error)
1121 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1124 if (Cursor.SkipBlock())
1127 MaybeNext = Cursor.advance();
1130 consumeError(MaybeNext.takeError());
1133 Next = MaybeNext.get();
1138 llvm::StringRef BlobData;
1140 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1143 consumeError(MaybeKind.takeError());
1146 unsigned Kind = MaybeKind.get();
1153 uint32_t tableOffset;
1154 objc_property_block::ObjCPropertyDataLayout::readRecord(Scratch,
1156 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1159 base + tableOffset, base +
sizeof(uint32_t), base));
1169 MaybeNext = Cursor.advance();
1172 consumeError(MaybeNext.takeError());
1175 Next = MaybeNext.get();
1189 consumeError(MaybeNext.takeError());
1192 llvm::BitstreamEntry
Next = MaybeNext.get();
1193 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1194 if (
Next.Kind == llvm::BitstreamEntry::Error)
1197 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1200 if (Cursor.SkipBlock())
1203 MaybeNext = Cursor.advance();
1206 consumeError(MaybeNext.takeError());
1209 Next = MaybeNext.get();
1214 llvm::StringRef BlobData;
1216 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1219 consumeError(MaybeKind.takeError());
1222 unsigned Kind = MaybeKind.get();
1229 uint32_t tableOffset;
1230 objc_method_block::ObjCMethodDataLayout::readRecord(Scratch, tableOffset);
1231 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1234 base + tableOffset, base +
sizeof(uint32_t), base));
1244 MaybeNext = Cursor.advance();
1247 consumeError(MaybeNext.takeError());
1250 Next = MaybeNext.get();
1264 consumeError(MaybeNext.takeError());
1267 llvm::BitstreamEntry
Next = MaybeNext.get();
1268 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1269 if (
Next.Kind == llvm::BitstreamEntry::Error)
1272 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1275 if (Cursor.SkipBlock())
1278 MaybeNext = Cursor.advance();
1281 consumeError(MaybeNext.takeError());
1284 Next = MaybeNext.get();
1289 llvm::StringRef BlobData;
1291 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1294 consumeError(MaybeKind.takeError());
1297 unsigned Kind = MaybeKind.get();
1304 uint32_t tableOffset;
1305 cxx_method_block::CXXMethodDataLayout::readRecord(Scratch, tableOffset);
1306 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1309 base + tableOffset, base +
sizeof(uint32_t), base));
1319 MaybeNext = Cursor.advance();
1322 consumeError(MaybeNext.takeError());
1325 Next = MaybeNext.get();
1339 consumeError(MaybeNext.takeError());
1342 llvm::BitstreamEntry
Next = MaybeNext.get();
1343 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1344 if (
Next.Kind == llvm::BitstreamEntry::Error)
1347 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1350 if (Cursor.SkipBlock())
1353 MaybeNext = Cursor.advance();
1356 consumeError(MaybeNext.takeError());
1359 Next = MaybeNext.get();
1364 llvm::StringRef BlobData;
1366 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1369 consumeError(MaybeKind.takeError());
1372 unsigned Kind = MaybeKind.get();
1379 uint32_t tableOffset;
1380 field_block::FieldDataLayout::readRecord(Scratch, tableOffset);
1381 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1383 FieldTable.reset(SerializedFieldTable::Create(
1384 base + tableOffset, base +
sizeof(uint32_t), base));
1394 MaybeNext = Cursor.advance();
1397 consumeError(MaybeNext.takeError());
1400 Next = MaybeNext.get();
1414 consumeError(MaybeNext.takeError());
1417 llvm::BitstreamEntry
Next = MaybeNext.get();
1418 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1419 if (
Next.Kind == llvm::BitstreamEntry::Error)
1422 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1425 if (Cursor.SkipBlock())
1428 MaybeNext = Cursor.advance();
1431 consumeError(MaybeNext.takeError());
1434 Next = MaybeNext.get();
1439 llvm::StringRef BlobData;
1441 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1444 consumeError(MaybeKind.takeError());
1447 unsigned Kind = MaybeKind.get();
1454 uint32_t tableOffset;
1455 objc_selector_block::ObjCSelectorDataLayout::readRecord(Scratch,
1457 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1460 base + tableOffset, base +
sizeof(uint32_t), base));
1470 MaybeNext = Cursor.advance();
1473 consumeError(MaybeNext.takeError());
1476 Next = MaybeNext.get();
1490 consumeError(MaybeNext.takeError());
1493 llvm::BitstreamEntry
Next = MaybeNext.get();
1494 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1495 if (
Next.Kind == llvm::BitstreamEntry::Error)
1498 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1501 if (Cursor.SkipBlock())
1504 MaybeNext = Cursor.advance();
1507 consumeError(MaybeNext.takeError());
1510 Next = MaybeNext.get();
1515 llvm::StringRef BlobData;
1517 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1520 consumeError(MaybeKind.takeError());
1523 unsigned Kind = MaybeKind.get();
1530 uint32_t tableOffset;
1531 global_variable_block::GlobalVariableDataLayout::readRecord(Scratch,
1533 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1536 base + tableOffset, base +
sizeof(uint32_t), base));
1546 MaybeNext = Cursor.advance();
1549 consumeError(MaybeNext.takeError());
1552 Next = MaybeNext.get();
1566 consumeError(MaybeNext.takeError());
1569 llvm::BitstreamEntry
Next = MaybeNext.get();
1570 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1571 if (
Next.Kind == llvm::BitstreamEntry::Error)
1574 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1577 if (Cursor.SkipBlock())
1580 MaybeNext = Cursor.advance();
1583 consumeError(MaybeNext.takeError());
1586 Next = MaybeNext.get();
1591 llvm::StringRef BlobData;
1593 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1596 consumeError(MaybeKind.takeError());
1599 unsigned Kind = MaybeKind.get();
1606 uint32_t tableOffset;
1607 global_function_block::GlobalFunctionDataLayout::readRecord(Scratch,
1609 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1612 base + tableOffset, base +
sizeof(uint32_t), base));
1622 MaybeNext = Cursor.advance();
1625 consumeError(MaybeNext.takeError());
1628 Next = MaybeNext.get();
1642 consumeError(MaybeNext.takeError());
1645 llvm::BitstreamEntry
Next = MaybeNext.get();
1646 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1647 if (
Next.Kind == llvm::BitstreamEntry::Error)
1650 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1653 if (Cursor.SkipBlock())
1656 MaybeNext = Cursor.advance();
1659 consumeError(MaybeNext.takeError());
1662 Next = MaybeNext.get();
1667 llvm::StringRef BlobData;
1669 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1672 consumeError(MaybeKind.takeError());
1675 unsigned Kind = MaybeKind.get();
1682 uint32_t tableOffset;
1683 enum_constant_block::EnumConstantDataLayout::readRecord(Scratch,
1685 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1688 base + tableOffset, base +
sizeof(uint32_t), base));
1698 MaybeNext = Cursor.advance();
1701 consumeError(MaybeNext.takeError());
1704 Next = MaybeNext.get();
1718 consumeError(MaybeNext.takeError());
1721 llvm::BitstreamEntry
Next = MaybeNext.get();
1722 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1723 if (
Next.Kind == llvm::BitstreamEntry::Error)
1726 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1729 if (Cursor.SkipBlock())
1732 MaybeNext = Cursor.advance();
1735 consumeError(MaybeNext.takeError());
1738 Next = MaybeNext.get();
1743 llvm::StringRef BlobData;
1745 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1748 consumeError(MaybeKind.takeError());
1751 unsigned Kind = MaybeKind.get();
1758 uint32_t tableOffset;
1759 tag_block::TagDataLayout::readRecord(Scratch, tableOffset);
1760 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1762 TagTable.reset(SerializedTagTable::Create(base + tableOffset,
1763 base +
sizeof(uint32_t), base));
1773 MaybeNext = Cursor.advance();
1776 consumeError(MaybeNext.takeError());
1779 Next = MaybeNext.get();
1793 consumeError(MaybeNext.takeError());
1796 llvm::BitstreamEntry
Next = MaybeNext.get();
1797 while (
Next.Kind != llvm::BitstreamEntry::EndBlock) {
1798 if (
Next.Kind == llvm::BitstreamEntry::Error)
1801 if (
Next.Kind == llvm::BitstreamEntry::SubBlock) {
1804 if (Cursor.SkipBlock())
1807 MaybeNext = Cursor.advance();
1810 consumeError(MaybeNext.takeError());
1813 Next = MaybeNext.get();
1818 llvm::StringRef BlobData;
1820 Cursor.readRecord(
Next.ID, Scratch, &BlobData);
1823 consumeError(MaybeKind.takeError());
1826 unsigned Kind = MaybeKind.get();
1833 uint32_t tableOffset;
1834 typedef_block::TypedefDataLayout::readRecord(Scratch, tableOffset);
1835 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1838 base + tableOffset, base +
sizeof(uint32_t), base));
1848 MaybeNext = Cursor.advance();
1851 consumeError(MaybeNext.takeError());
1854 Next = MaybeNext.get();
1860APINotesReader::APINotesReader(llvm::MemoryBuffer *InputBuffer,
1861 llvm::VersionTuple SwiftVersion,
bool &Failed)
1872 if (Cursor.AtEndOfStream()) {
1878 if (maybeRead.get() !=
byte) {
1884 consumeError(maybeRead.takeError());
1891 bool HasValidControlBlock =
false;
1892 llvm::SmallVector<uint64_t, 64> Scratch;
1893 while (!
Cursor.AtEndOfStream()) {
1894 llvm::Expected<llvm::BitstreamEntry> MaybeTopLevelEntry =
Cursor.advance();
1895 if (!MaybeTopLevelEntry) {
1897 consumeError(MaybeTopLevelEntry.takeError());
1901 llvm::BitstreamEntry TopLevelEntry = MaybeTopLevelEntry.get();
1903 if (TopLevelEntry.Kind != llvm::BitstreamEntry::SubBlock)
1906 switch (TopLevelEntry.ID) {
1907 case llvm::bitc::BLOCKINFO_BLOCK_ID:
1908 if (!
Cursor.ReadBlockInfoBlock()) {
1916 if (HasValidControlBlock ||
1917 Implementation->readControlBlock(Cursor, Scratch)) {
1922 HasValidControlBlock =
true;
1926 if (!HasValidControlBlock ||
1927 Implementation->readIdentifierBlock(Cursor, Scratch)) {
1934 if (!HasValidControlBlock ||
1935 Implementation->readContextBlock(Cursor, Scratch)) {
1943 if (!HasValidControlBlock ||
1944 Implementation->readObjCPropertyBlock(Cursor, Scratch)) {
1951 if (!HasValidControlBlock ||
1952 Implementation->readObjCMethodBlock(Cursor, Scratch)) {
1959 if (!HasValidControlBlock ||
1960 Implementation->readCXXMethodBlock(Cursor, Scratch)) {
1967 if (!HasValidControlBlock ||
1968 Implementation->readFieldBlock(Cursor, Scratch)) {
1975 if (!HasValidControlBlock ||
1976 Implementation->readObjCSelectorBlock(Cursor, Scratch)) {
1983 if (!HasValidControlBlock ||
1984 Implementation->readGlobalVariableBlock(Cursor, Scratch)) {
1991 if (!HasValidControlBlock ||
1992 Implementation->readGlobalFunctionBlock(Cursor, Scratch)) {
1999 if (!HasValidControlBlock ||
2000 Implementation->readEnumConstantBlock(Cursor, Scratch)) {
2007 if (!HasValidControlBlock ||
2008 Implementation->readTagBlock(Cursor, Scratch)) {
2015 if (!HasValidControlBlock ||
2016 Implementation->readTypedefBlock(Cursor, Scratch)) {
2025 if (
Cursor.SkipBlock()) {
2033 if (!
Cursor.AtEndOfStream()) {
2041std::unique_ptr<APINotesReader>
2043 llvm::VersionTuple SwiftVersion) {
2044 bool Failed =
false;
2045 std::unique_ptr<APINotesReader> Reader(
2046 new APINotesReader(InputBuffer.release(), SwiftVersion, Failed));
2053template <
typename T>
2055 llvm::VersionTuple Version,
2057 : Results(
std::move(R)) {
2059 assert(!Results.empty());
2060 assert(llvm::is_sorted(
2062 [](
const std::pair<llvm::VersionTuple, T> &left,
2063 const std::pair<llvm::VersionTuple, T> &right) ->
bool {
2068 assert((&left == &right || left.first != right.first) &&
2069 "two entries for the same version");
2070 return left.first < right.first;
2073 Selected = std::nullopt;
2074 for (
unsigned i = 0, n = Results.size(); i != n; ++i) {
2075 if (!Version.empty() && Results[i].first >= Version) {
2087 if (!Selected && Results[0].first.empty())
2092 -> std::optional<ContextID> {
2094 return std::nullopt;
2098 return std::nullopt;
2105 return std::nullopt;
2113 return std::nullopt;
2117 return std::nullopt;
2121 return std::nullopt;
2127 -> std::optional<ContextID> {
2129 return std::nullopt;
2133 return std::nullopt;
2140 return std::nullopt;
2148 return std::nullopt;
2152 return std::nullopt;
2156 return std::nullopt;
2165 return std::nullopt;
2169 return std::nullopt;
2172 std::make_tuple(CtxID.Value, *PropertyID, (
char)IsInstance));
2174 return std::nullopt;
2180 bool IsInstanceMethod)
2183 return std::nullopt;
2187 return std::nullopt;
2190 ObjCMethodTableInfo::internal_key_type{CtxID.Value, *SelID,
2193 return std::nullopt;
2201 return std::nullopt;
2205 return std::nullopt;
2210 return std::nullopt;
2218 return std::nullopt;
2222 return std::nullopt;
2227 return std::nullopt;
2233 std::optional<Context> Ctx)
2236 return std::nullopt;
2240 return std::nullopt;
2246 return std::nullopt;
2252 std::optional<Context> Ctx)
2255 return std::nullopt;
2259 return std::nullopt;
2265 return std::nullopt;
2273 return std::nullopt;
2277 return std::nullopt;
2281 return std::nullopt;
2287 std::optional<Context> ParentCtx)
2288 -> std::optional<ContextID> {
2290 return std::nullopt;
2294 return std::nullopt;
2299 return std::nullopt;
2307 return std::nullopt;
2311 return std::nullopt;
2317 return std::nullopt;
2323 std::optional<Context> Ctx)
2326 return std::nullopt;
2330 return std::nullopt;
2336 return std::nullopt;
2342 llvm::StringRef Name, std::optional<ContextID> ParentNamespaceID)
2343 -> std::optional<ContextID> {
2345 return std::nullopt;
2349 return std::nullopt;
2351 uint32_t RawParentNamespaceID =
2352 ParentNamespaceID ? ParentNamespaceID->Value : -1;
2356 return std::nullopt;
static StringRef getIdentifier(const Token &Tok)
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Smart pointer class that efficiently represents Objective-C method names.
llvm::OnDiskIterableChainedHashTable< FieldTableInfo > SerializedFieldTable
std::unique_ptr< SerializedContextIDTable > ContextIDTable
The Objective-C / C++ context ID table.
bool readEnumConstantBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::string ModuleName
The name of the module that we read from the control block.
std::optional< std::pair< off_t, time_t > > SourceFileSizeAndModTime
std::unique_ptr< SerializedIdentifierTable > IdentifierTable
The identifier table.
llvm::OnDiskIterableChainedHashTable< TagTableInfo > SerializedTagTable
llvm::OnDiskIterableChainedHashTable< GlobalFunctionTableInfo > SerializedGlobalFunctionTable
std::unique_ptr< SerializedGlobalFunctionTable > GlobalFunctionTable
The global function table.
std::unique_ptr< SerializedObjCPropertyTable > ObjCPropertyTable
The Objective-C property table.
bool readObjCMethodBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::OnDiskIterableChainedHashTable< EnumConstantTableInfo > SerializedEnumConstantTable
std::unique_ptr< SerializedGlobalVariableTable > GlobalVariableTable
The global variable table.
bool readTagBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::unique_ptr< SerializedTypedefTable > TypedefTable
The typedef table.
bool readFieldBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readGlobalFunctionBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readTypedefBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::MemoryBuffer * InputBuffer
The input buffer for the API notes data.
std::unique_ptr< SerializedObjCSelectorTable > ObjCSelectorTable
The Objective-C selector table.
llvm::OnDiskIterableChainedHashTable< ObjCMethodTableInfo > SerializedObjCMethodTable
bool readControlBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::OnDiskIterableChainedHashTable< CXXMethodTableInfo > SerializedCXXMethodTable
llvm::OnDiskIterableChainedHashTable< ContextInfoTableInfo > SerializedContextInfoTable
std::unique_ptr< SerializedCXXMethodTable > CXXMethodTable
The C++ method table.
llvm::OnDiskIterableChainedHashTable< ObjCSelectorTableInfo > SerializedObjCSelectorTable
llvm::OnDiskIterableChainedHashTable< IdentifierTableInfo > SerializedIdentifierTable
bool readObjCPropertyBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readObjCSelectorBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::unique_ptr< SerializedEnumConstantTable > EnumConstantTable
The enumerator table.
std::optional< IdentifierID > getIdentifier(llvm::StringRef Str)
Retrieve the identifier ID for the given string, or an empty optional if the string is unknown.
bool readGlobalVariableBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::unique_ptr< SerializedTagTable > TagTable
The tag table.
std::unique_ptr< SerializedFieldTable > FieldTable
The C record field table.
std::optional< SelectorID > getSelector(ObjCSelectorRef Selector)
Retrieve the selector ID for the given selector, or an empty optional if the string is unknown.
llvm::OnDiskIterableChainedHashTable< TypedefTableInfo > SerializedTypedefTable
bool readCXXMethodBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readIdentifierBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::OnDiskIterableChainedHashTable< GlobalVariableTableInfo > SerializedGlobalVariableTable
llvm::VersionTuple SwiftVersion
The Swift version to use for filtering.
llvm::OnDiskIterableChainedHashTable< ContextIDTableInfo > SerializedContextIDTable
bool readContextBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::unique_ptr< SerializedObjCMethodTable > ObjCMethodTable
The Objective-C method table.
std::unique_ptr< SerializedContextInfoTable > ContextInfoTable
The Objective-C context info table.
llvm::OnDiskIterableChainedHashTable< ObjCPropertyTableInfo > SerializedObjCPropertyTable
Captures the completed versioned information for a particular part of API notes, including both unver...
VersionedInfo(std::nullopt_t)
Form an empty set of versioned information.
VersionedInfo< ContextInfo > lookupObjCClassInfo(llvm::StringRef Name)
Look for information regarding the given Objective-C class.
VersionedInfo< FieldInfo > lookupField(ContextID CtxID, llvm::StringRef Name)
Look for information regarding the given field of a C struct.
VersionedInfo< CXXMethodInfo > lookupCXXMethod(ContextID CtxID, llvm::StringRef Name)
Look for information regarding the given C++ method in the given C++ tag context.
VersionedInfo< TagInfo > lookupTag(llvm::StringRef Name, std::optional< Context > Ctx=std::nullopt)
Look for information regarding the given tag (struct/union/enum/C++ class).
VersionedInfo< GlobalFunctionInfo > lookupGlobalFunction(llvm::StringRef Name, std::optional< Context > Ctx=std::nullopt)
Look for information regarding the given global function.
VersionedInfo< ObjCPropertyInfo > lookupObjCProperty(ContextID CtxID, llvm::StringRef Name, bool IsInstance)
Look for information regarding the given Objective-C property in the given context.
VersionedInfo< ObjCMethodInfo > lookupObjCMethod(ContextID CtxID, ObjCSelectorRef Selector, bool IsInstanceMethod)
Look for information regarding the given Objective-C method in the given context.
VersionedInfo< GlobalVariableInfo > lookupGlobalVariable(llvm::StringRef Name, std::optional< Context > Ctx=std::nullopt)
Look for information regarding the given global variable.
std::optional< ContextID > lookupNamespaceID(llvm::StringRef Name, std::optional< ContextID > ParentNamespaceID=std::nullopt)
Look for the context ID of the given C++ namespace.
std::optional< ContextID > lookupTagID(llvm::StringRef Name, std::optional< Context > ParentCtx=std::nullopt)
Look for the context ID of the given C++ tag.
VersionedInfo< TypedefInfo > lookupTypedef(llvm::StringRef Name, std::optional< Context > Ctx=std::nullopt)
Look for information regarding the given typedef.
std::optional< ContextID > lookupObjCClassID(llvm::StringRef Name)
Look for the context ID of the given Objective-C class.
static std::unique_ptr< APINotesReader > Create(std::unique_ptr< llvm::MemoryBuffer > InputBuffer, llvm::VersionTuple SwiftVersion)
Create a new API notes reader from the given member buffer, which contains the contents of a binary A...
VersionedInfo< ContextInfo > lookupObjCProtocolInfo(llvm::StringRef Name)
Look for information regarding the given Objective-C protocol.
std::optional< ContextID > lookupObjCProtocolID(llvm::StringRef Name)
Look for the context ID of the given Objective-C protocol.
VersionedInfo< EnumConstantInfo > lookupEnumConstant(llvm::StringRef Name)
Look for information regarding the given enumerator.
Describes API notes data for any entity.
Describes API notes for types.
Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace.
API notes for a function or method.
Describes a function or method parameter.
API notes for a variable/property.
RetainCountConventionKind
llvm::PointerEmbeddedInt< unsigned, 31 > IdentifierID
llvm::PointerEmbeddedInt< unsigned, 31 > SelectorID
const uint8_t kSwiftConforms
SwiftNewTypeKind
The kind of a swift_wrapper/swift_newtype.
EnumExtensibilityKind
The payload for an enum_extensibility attribute.
const uint8_t kSwiftDoesNotConform
const uint16_t VERSION_MAJOR
API notes file major version number.
const unsigned char API_NOTES_SIGNATURE[]
Magic number for API notes files.
const uint16_t VERSION_MINOR
API notes file minor version number.
@ OBJC_CONTEXT_BLOCK_ID
The Objective-C context data block, which contains information about Objective-C classes and protocol...
@ TYPEDEF_BLOCK_ID
The typedef data block, which maps typedef names to information about the typedefs.
@ OBJC_PROPERTY_BLOCK_ID
The Objective-C property data block, which maps Objective-C (class name, property name) pairs to info...
@ ENUM_CONSTANT_BLOCK_ID
The enum constant data block, which maps enumerator names to information about the enumerators.
@ TAG_BLOCK_ID
The tag data block, which maps tag names to information about the tags.
@ OBJC_METHOD_BLOCK_ID
The Objective-C property data block, which maps Objective-C (class name, selector,...
@ FIELD_BLOCK_ID
The fields data block, which maps names fields of C records to information about the field.
@ OBJC_SELECTOR_BLOCK_ID
The Objective-C selector data block, which maps Objective-C selector names (# of pieces,...
@ CXX_METHOD_BLOCK_ID
The C++ method data block, which maps C++ (context id, method name) pairs to information about the me...
@ GLOBAL_FUNCTION_BLOCK_ID
The (global) functions data block, which maps global function names to information about the global f...
@ CONTROL_BLOCK_ID
The control block, which contains all of the information that needs to be validated prior to committi...
@ IDENTIFIER_BLOCK_ID
The identifier data block, which maps identifier strings to IDs.
@ GLOBAL_VARIABLE_BLOCK_ID
The global variables data block, which maps global variable names to information about the global var...
unsigned ComputeHash(Selector Sel)
The JSON file list parser is used to communicate input to InstallAPI.
NullabilityKind
Describes the nullability of a particular type.
@ Result
The result type of a method or function.
hash_code hash_value(const clang::tooling::dependencies::ModuleID &ID)
A stored Objective-C or C++ context, represented by the ID of its parent context, the kind of this co...
A temporary reference to an Objective-C selector, suitable for referencing selector data on the stack...
A stored Objective-C or C++ declaration, represented by the ID of its parent context,...
A stored Objective-C selector.
llvm::SmallVector< IdentifierID, 2 > Identifiers