17#include "llvm/ADT/Hashing.h"
18#include "llvm/ADT/StringExtras.h"
19#include "llvm/Bitstream/BitstreamReader.h"
20#include "llvm/Support/DJB.h"
21#include "llvm/Support/EndianStream.h"
22#include "llvm/Support/OnDiskHashTable.h"
26using namespace llvm::support;
30llvm::VersionTuple ReadVersionTuple(
const uint8_t *&
Data) {
31 uint8_t NumVersions = (*
Data++) & 0x03;
33 unsigned Major = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
35 return llvm::VersionTuple(Major);
37 unsigned Minor = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
39 return llvm::VersionTuple(Major, Minor);
42 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
44 return llvm::VersionTuple(Major, Minor, Subminor);
46 unsigned Build = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
47 return llvm::VersionTuple(Major, Minor, Subminor, Build);
51template <
typename Derived,
typename KeyType,
typename UnversionedDataType>
52class VersionedTableInfo {
54 using internal_key_type = KeyType;
55 using external_key_type = KeyType;
58 using hash_value_type =
size_t;
61 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
63 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
65 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
69 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
71 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
73 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
74 return {KeyLength, DataLength};
77 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
79 unsigned NumElements =
80 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
82 Result.reserve(NumElements);
83 for (
unsigned i = 0; i != NumElements; ++i) {
84 auto version = ReadVersionTuple(
Data);
85 const auto *DataBefore =
Data;
87 auto UnversionedData = Derived::readUnversioned(Key,
Data);
88 assert(
Data != DataBefore &&
89 "Unversioned data reader didn't move pointer");
90 Result.push_back({version, UnversionedData});
97void ReadCommonEntityInfo(
const uint8_t *&
Data, CommonEntityInfo &Info) {
98 uint8_t UnavailableBits = *
Data++;
99 Info.Unavailable = (UnavailableBits >> 1) & 0x01;
100 Info.UnavailableInSwift = UnavailableBits & 0x01;
101 if ((UnavailableBits >> 2) & 0x01)
102 Info.setSwiftPrivate(
static_cast<bool>((UnavailableBits >> 3) & 0x01));
105 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
106 Info.UnavailableMsg =
107 std::string(
reinterpret_cast<const char *
>(
Data),
108 reinterpret_cast<const char *
>(
Data) + MsgLength);
111 unsigned SwiftNameLength =
112 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
114 std::string(
reinterpret_cast<const char *
>(
Data),
115 reinterpret_cast<const char *
>(
Data) + SwiftNameLength);
116 Data += SwiftNameLength;
120void ReadCommonTypeInfo(
const uint8_t *&
Data, CommonTypeInfo &Info) {
121 ReadCommonEntityInfo(
Data, Info);
123 unsigned SwiftBridgeLength =
124 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
125 if (SwiftBridgeLength > 0) {
126 Info.setSwiftBridge(std::string(
reinterpret_cast<const char *
>(
Data),
127 SwiftBridgeLength - 1));
128 Data += SwiftBridgeLength - 1;
131 unsigned ErrorDomainLength =
132 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
133 if (ErrorDomainLength > 0) {
134 Info.setNSErrorDomain(std::optional<std::string>(std::string(
135 reinterpret_cast<const char *
>(
Data), ErrorDomainLength - 1)));
136 Data += ErrorDomainLength - 1;
141class IdentifierTableInfo {
143 using internal_key_type = llvm::StringRef;
144 using external_key_type = llvm::StringRef;
146 using hash_value_type = uint32_t;
149 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
151 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
153 hash_value_type
ComputeHash(internal_key_type Key) {
154 return llvm::djbHash(Key);
157 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
161 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
163 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
164 unsigned DataLength =
165 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
166 return {KeyLength, DataLength};
169 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
170 return llvm::StringRef(
reinterpret_cast<const char *
>(
Data), Length);
173 static data_type ReadData(internal_key_type key,
const uint8_t *
Data,
175 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
181class ContextIDTableInfo {
183 using internal_key_type = ContextTableKey;
184 using external_key_type = internal_key_type;
186 using hash_value_type =
size_t;
189 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
191 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
193 hash_value_type
ComputeHash(internal_key_type Key) {
194 return static_cast<size_t>(Key.hashValue());
197 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
201 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
203 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
204 unsigned DataLength =
205 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
206 return {KeyLength, DataLength};
209 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
211 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
213 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
214 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
218 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
220 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
225class ContextInfoTableInfo
226 :
public VersionedTableInfo<ContextInfoTableInfo, unsigned, ContextInfo> {
228 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
229 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
232 hash_value_type
ComputeHash(internal_key_type Key) {
236 static ContextInfo readUnversioned(internal_key_type Key,
237 const uint8_t *&
Data) {
239 ReadCommonTypeInfo(
Data, Info);
240 uint8_t Payload = *
Data++;
243 Info.setHasDesignatedInits(
true);
244 Payload = Payload >> 1;
247 Info.setDefaultNullability(
static_cast<NullabilityKind>(Payload & 0x03));
250 if (Payload & (1 << 1))
251 Info.setSwiftObjCMembers(Payload & 1);
254 if (Payload & (1 << 1))
255 Info.setSwiftImportAsNonGeneric(Payload & 1);
262void ReadVariableInfo(
const uint8_t *&
Data, VariableInfo &Info) {
263 ReadCommonEntityInfo(
Data, Info);
269 auto TypeLen = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
270 Info.setType(std::string(
Data,
Data + TypeLen));
275class ObjCPropertyTableInfo
276 :
public VersionedTableInfo<ObjCPropertyTableInfo,
277 std::tuple<uint32_t, uint32_t, uint8_t>,
280 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
281 auto ClassID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
282 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
283 char IsInstance = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
284 return {ClassID, NameID, IsInstance};
287 hash_value_type
ComputeHash(internal_key_type Key) {
291 static ObjCPropertyInfo readUnversioned(internal_key_type Key,
292 const uint8_t *&
Data) {
293 ObjCPropertyInfo Info;
294 ReadVariableInfo(
Data, Info);
295 uint8_t Flags = *
Data++;
296 if (Flags & (1 << 0))
297 Info.setSwiftImportAsAccessors(Flags & (1 << 1));
303void ReadParamInfo(
const uint8_t *&
Data, ParamInfo &Info) {
304 ReadVariableInfo(
Data, Info);
306 uint8_t Payload = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
307 if (
auto RawConvention = Payload & 0x7) {
309 Info.setRetainCountConvention(Convention);
313 Info.setNoEscape(Payload & 0x02);
315 assert(Payload == 0 &&
"Bad API notes");
319void ReadFunctionInfo(
const uint8_t *&
Data, FunctionInfo &Info) {
320 ReadCommonEntityInfo(
Data, Info);
322 uint8_t Payload = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
323 if (
auto RawConvention = Payload & 0x7) {
325 Info.setRetainCountConvention(Convention);
328 Info.NullabilityAudited = Payload & 0x1;
330 assert(Payload == 0 &&
"Bad API notes");
332 Info.NumAdjustedNullable =
333 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
334 Info.NullabilityPayload =
335 endian::readNext<uint64_t, llvm::endianness::little>(
Data);
338 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
339 while (NumParams > 0) {
341 ReadParamInfo(
Data, pi);
342 Info.Params.push_back(pi);
346 unsigned ResultTypeLen =
347 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
348 Info.ResultType = std::string(
Data,
Data + ResultTypeLen);
349 Data += ResultTypeLen;
353class ObjCMethodTableInfo
354 :
public VersionedTableInfo<ObjCMethodTableInfo,
355 std::tuple<uint32_t, uint32_t, uint8_t>,
358 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
359 auto ClassID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
361 endian::readNext<uint32_t, llvm::endianness::little>(
Data);
362 auto IsInstance = endian::readNext<uint8_t, llvm::endianness::little>(
Data);
366 hash_value_type
ComputeHash(internal_key_type Key) {
370 static ObjCMethodInfo readUnversioned(internal_key_type Key,
371 const uint8_t *&
Data) {
373 uint8_t Payload = *
Data++;
374 Info.RequiredInit = Payload & 0x01;
376 Info.DesignatedInit = Payload & 0x01;
379 ReadFunctionInfo(
Data, Info);
385class ObjCSelectorTableInfo {
387 using internal_key_type = StoredObjCSelector;
388 using external_key_type = internal_key_type;
393 internal_key_type GetInternalKey(external_key_type Key) {
return Key; }
395 external_key_type GetExternalKey(internal_key_type Key) {
return Key; }
397 hash_value_type
ComputeHash(internal_key_type Key) {
398 return llvm::DenseMapInfo<StoredObjCSelector>::getHashValue(Key);
401 static bool EqualKey(internal_key_type LHS, internal_key_type RHS) {
402 return llvm::DenseMapInfo<StoredObjCSelector>::isEqual(LHS, RHS);
405 static std::pair<unsigned, unsigned> ReadKeyDataLength(
const uint8_t *&
Data) {
407 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
408 unsigned DataLength =
409 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
410 return {KeyLength, DataLength};
413 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
414 internal_key_type Key;
415 Key.NumArgs = endian::readNext<uint16_t, llvm::endianness::little>(
Data);
416 unsigned NumIdents = (Length -
sizeof(uint16_t)) /
sizeof(uint32_t);
417 for (
unsigned i = 0; i != NumIdents; ++i) {
418 Key.Identifiers.push_back(
419 endian::readNext<uint32_t, llvm::endianness::little>(
Data));
424 static data_type ReadData(internal_key_type Key,
const uint8_t *
Data,
426 return endian::readNext<uint32_t, llvm::endianness::little>(
Data);
431class GlobalVariableTableInfo
432 :
public VersionedTableInfo<GlobalVariableTableInfo, SingleDeclTableKey,
433 GlobalVariableInfo> {
435 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
436 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
437 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
438 return {CtxID, NameID};
441 hash_value_type
ComputeHash(internal_key_type Key) {
442 return static_cast<size_t>(Key.hashValue());
445 static GlobalVariableInfo readUnversioned(internal_key_type Key,
446 const uint8_t *&
Data) {
447 GlobalVariableInfo Info;
448 ReadVariableInfo(
Data, Info);
454class GlobalFunctionTableInfo
455 :
public VersionedTableInfo<GlobalFunctionTableInfo, SingleDeclTableKey,
456 GlobalFunctionInfo> {
458 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
459 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
460 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
461 return {CtxID, NameID};
464 hash_value_type
ComputeHash(internal_key_type Key) {
465 return static_cast<size_t>(Key.hashValue());
468 static GlobalFunctionInfo readUnversioned(internal_key_type Key,
469 const uint8_t *&
Data) {
470 GlobalFunctionInfo Info;
471 ReadFunctionInfo(
Data, Info);
477class CXXMethodTableInfo
478 :
public VersionedTableInfo<CXXMethodTableInfo, SingleDeclTableKey,
481 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
482 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
483 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
484 return {CtxID, NameID};
487 hash_value_type
ComputeHash(internal_key_type Key) {
488 return static_cast<size_t>(Key.hashValue());
491 static CXXMethodInfo readUnversioned(internal_key_type Key,
492 const uint8_t *&
Data) {
494 ReadFunctionInfo(
Data, Info);
500class EnumConstantTableInfo
501 :
public VersionedTableInfo<EnumConstantTableInfo, uint32_t,
504 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
505 auto NameID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
509 hash_value_type
ComputeHash(internal_key_type Key) {
513 static EnumConstantInfo readUnversioned(internal_key_type Key,
514 const uint8_t *&
Data) {
515 EnumConstantInfo Info;
516 ReadCommonEntityInfo(
Data, Info);
523 :
public VersionedTableInfo<TagTableInfo, SingleDeclTableKey, TagInfo> {
525 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
526 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
528 endian::readNext<IdentifierID, llvm::endianness::little>(
Data);
529 return {CtxID, NameID};
532 hash_value_type
ComputeHash(internal_key_type Key) {
533 return static_cast<size_t>(Key.hashValue());
536 static TagInfo readUnversioned(internal_key_type Key,
const uint8_t *&
Data) {
539 uint8_t Payload = *
Data++;
541 Info.setFlagEnum(Payload & 2);
544 Info.EnumExtensibility =
548 endian::readNext<uint8_t, llvm::endianness::little>(
Data);
550 Info.setSwiftCopyable(std::optional(
false));
552 Info.setSwiftCopyable(std::optional(
true));
554 unsigned ImportAsLength =
555 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
556 if (ImportAsLength > 0) {
558 std::string(
reinterpret_cast<const char *
>(
Data), ImportAsLength - 1);
559 Data += ImportAsLength - 1;
561 unsigned RetainOpLength =
562 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
563 if (RetainOpLength > 0) {
565 std::string(
reinterpret_cast<const char *
>(
Data), RetainOpLength - 1);
566 Data += RetainOpLength - 1;
568 unsigned ReleaseOpLength =
569 endian::readNext<uint16_t, llvm::endianness::little>(
Data);
570 if (ReleaseOpLength > 0) {
571 Info.SwiftReleaseOp = std::string(
reinterpret_cast<const char *
>(
Data),
572 ReleaseOpLength - 1);
573 Data += ReleaseOpLength - 1;
576 ReadCommonTypeInfo(
Data, Info);
582class TypedefTableInfo
583 :
public VersionedTableInfo<TypedefTableInfo, SingleDeclTableKey,
586 static internal_key_type ReadKey(
const uint8_t *
Data,
unsigned Length) {
587 auto CtxID = endian::readNext<uint32_t, llvm::endianness::little>(
Data);
589 endian::readNext<IdentifierID, llvm::endianness::little>(
Data);
590 return {CtxID, nameID};
593 hash_value_type
ComputeHash(internal_key_type Key) {
594 return static_cast<size_t>(Key.hashValue());
597 static TypedefInfo readUnversioned(internal_key_type Key,
598 const uint8_t *&
Data) {
601 uint8_t Payload = *
Data++;
605 ReadCommonTypeInfo(
Data, Info);
627 llvm::OnDiskIterableChainedHashTable<IdentifierTableInfo>;
633 llvm::OnDiskIterableChainedHashTable<ContextIDTableInfo>;
639 llvm::OnDiskIterableChainedHashTable<ContextInfoTableInfo>;
645 llvm::OnDiskIterableChainedHashTable<ObjCPropertyTableInfo>;
651 llvm::OnDiskIterableChainedHashTable<ObjCMethodTableInfo>;
657 llvm::OnDiskIterableChainedHashTable<CXXMethodTableInfo>;
663 llvm::OnDiskIterableChainedHashTable<ObjCSelectorTableInfo>;
669 llvm::OnDiskIterableChainedHashTable<GlobalVariableTableInfo>;
675 llvm::OnDiskIterableChainedHashTable<GlobalFunctionTableInfo>;
681 llvm::OnDiskIterableChainedHashTable<EnumConstantTableInfo>;
692 llvm::OnDiskIterableChainedHashTable<TypedefTableInfo>;
699 std::optional<IdentifierID>
getIdentifier(llvm::StringRef Str);
731std::optional<IdentifierID>
746std::optional<SelectorID>
754 for (
auto Ident :
Selector.Identifiers) {
762 auto Known = ObjCSelectorTable->find(Key);
763 if (Known == ObjCSelectorTable->end())
774 bool SawMetadata =
false;
779 consumeError(MaybeNext.takeError());
782 llvm::BitstreamEntry Next = MaybeNext.get();
784 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
785 if (Next.Kind == llvm::BitstreamEntry::Error)
788 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
791 if (Cursor.SkipBlock())
794 MaybeNext = Cursor.advance();
797 consumeError(MaybeNext.takeError());
800 Next = MaybeNext.get();
805 llvm::StringRef BlobData;
807 Cursor.readRecord(Next.ID, Scratch, &BlobData);
810 consumeError(MaybeKind.takeError());
813 unsigned Kind = MaybeKind.get();
828 ModuleName = BlobData.str();
835 SourceFileSizeAndModTime = {Scratch[0], Scratch[1]};
844 MaybeNext = Cursor.advance();
847 consumeError(MaybeNext.takeError());
850 Next = MaybeNext.get();
864 consumeError(MaybeNext.takeError());
867 llvm::BitstreamEntry Next = MaybeNext.get();
869 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
870 if (Next.Kind == llvm::BitstreamEntry::Error)
873 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
876 if (Cursor.SkipBlock())
879 MaybeNext = Cursor.advance();
882 consumeError(MaybeNext.takeError());
885 Next = MaybeNext.get();
890 llvm::StringRef BlobData;
892 Cursor.readRecord(Next.ID, Scratch, &BlobData);
895 consumeError(MaybeKind.takeError());
898 unsigned Kind = MaybeKind.get();
905 uint32_t tableOffset;
906 identifier_block::IdentifierDataLayout::readRecord(Scratch, tableOffset);
907 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
910 base + tableOffset, base +
sizeof(uint32_t), base));
920 MaybeNext = Cursor.advance();
923 consumeError(MaybeNext.takeError());
926 Next = MaybeNext.get();
940 consumeError(MaybeNext.takeError());
943 llvm::BitstreamEntry Next = MaybeNext.get();
945 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
946 if (Next.Kind == llvm::BitstreamEntry::Error)
949 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
952 if (Cursor.SkipBlock())
955 MaybeNext = Cursor.advance();
958 consumeError(MaybeNext.takeError());
961 Next = MaybeNext.get();
966 llvm::StringRef BlobData;
968 Cursor.readRecord(Next.ID, Scratch, &BlobData);
971 consumeError(MaybeKind.takeError());
974 unsigned Kind = MaybeKind.get();
981 uint32_t tableOffset;
982 context_block::ContextIDLayout::readRecord(Scratch, tableOffset);
983 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
985 ContextIDTable.reset(SerializedContextIDTable::Create(
986 base + tableOffset, base +
sizeof(uint32_t), base));
992 if (ContextInfoTable)
995 uint32_t tableOffset;
996 context_block::ContextInfoLayout::readRecord(Scratch, tableOffset);
997 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
999 ContextInfoTable.reset(SerializedContextInfoTable::Create(
1000 base + tableOffset, base +
sizeof(uint32_t), base));
1010 MaybeNext = Cursor.advance();
1013 consumeError(MaybeNext.takeError());
1016 Next = MaybeNext.get();
1030 consumeError(MaybeNext.takeError());
1033 llvm::BitstreamEntry Next = MaybeNext.get();
1035 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1036 if (Next.Kind == llvm::BitstreamEntry::Error)
1039 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1042 if (Cursor.SkipBlock())
1045 MaybeNext = Cursor.advance();
1048 consumeError(MaybeNext.takeError());
1051 Next = MaybeNext.get();
1056 llvm::StringRef BlobData;
1058 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1061 consumeError(MaybeKind.takeError());
1064 unsigned Kind = MaybeKind.get();
1068 if (ObjCPropertyTable)
1071 uint32_t tableOffset;
1072 objc_property_block::ObjCPropertyDataLayout::readRecord(Scratch,
1074 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1076 ObjCPropertyTable.reset(SerializedObjCPropertyTable::Create(
1077 base + tableOffset, base +
sizeof(uint32_t), base));
1087 MaybeNext = Cursor.advance();
1090 consumeError(MaybeNext.takeError());
1093 Next = MaybeNext.get();
1107 consumeError(MaybeNext.takeError());
1110 llvm::BitstreamEntry Next = MaybeNext.get();
1111 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1112 if (Next.Kind == llvm::BitstreamEntry::Error)
1115 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1118 if (Cursor.SkipBlock())
1121 MaybeNext = Cursor.advance();
1124 consumeError(MaybeNext.takeError());
1127 Next = MaybeNext.get();
1132 llvm::StringRef BlobData;
1134 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1137 consumeError(MaybeKind.takeError());
1140 unsigned Kind = MaybeKind.get();
1144 if (ObjCMethodTable)
1147 uint32_t tableOffset;
1148 objc_method_block::ObjCMethodDataLayout::readRecord(Scratch, tableOffset);
1149 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1151 ObjCMethodTable.reset(SerializedObjCMethodTable::Create(
1152 base + tableOffset, base +
sizeof(uint32_t), base));
1162 MaybeNext = Cursor.advance();
1165 consumeError(MaybeNext.takeError());
1168 Next = MaybeNext.get();
1182 consumeError(MaybeNext.takeError());
1185 llvm::BitstreamEntry Next = MaybeNext.get();
1186 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1187 if (Next.Kind == llvm::BitstreamEntry::Error)
1190 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1193 if (Cursor.SkipBlock())
1196 MaybeNext = Cursor.advance();
1199 consumeError(MaybeNext.takeError());
1202 Next = MaybeNext.get();
1207 llvm::StringRef BlobData;
1209 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1212 consumeError(MaybeKind.takeError());
1215 unsigned Kind = MaybeKind.get();
1222 uint32_t tableOffset;
1223 cxx_method_block::CXXMethodDataLayout::readRecord(Scratch, tableOffset);
1224 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1226 CXXMethodTable.reset(SerializedCXXMethodTable::Create(
1227 base + tableOffset, base +
sizeof(uint32_t), base));
1237 MaybeNext = Cursor.advance();
1240 consumeError(MaybeNext.takeError());
1243 Next = MaybeNext.get();
1257 consumeError(MaybeNext.takeError());
1260 llvm::BitstreamEntry Next = MaybeNext.get();
1261 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1262 if (Next.Kind == llvm::BitstreamEntry::Error)
1265 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1268 if (Cursor.SkipBlock())
1271 MaybeNext = Cursor.advance();
1274 consumeError(MaybeNext.takeError());
1277 Next = MaybeNext.get();
1282 llvm::StringRef BlobData;
1284 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1287 consumeError(MaybeKind.takeError());
1290 unsigned Kind = MaybeKind.get();
1294 if (ObjCSelectorTable)
1297 uint32_t tableOffset;
1298 objc_selector_block::ObjCSelectorDataLayout::readRecord(Scratch,
1300 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1302 ObjCSelectorTable.reset(SerializedObjCSelectorTable::Create(
1303 base + tableOffset, base +
sizeof(uint32_t), base));
1313 MaybeNext = Cursor.advance();
1316 consumeError(MaybeNext.takeError());
1319 Next = MaybeNext.get();
1333 consumeError(MaybeNext.takeError());
1336 llvm::BitstreamEntry Next = MaybeNext.get();
1337 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1338 if (Next.Kind == llvm::BitstreamEntry::Error)
1341 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1344 if (Cursor.SkipBlock())
1347 MaybeNext = Cursor.advance();
1350 consumeError(MaybeNext.takeError());
1353 Next = MaybeNext.get();
1358 llvm::StringRef BlobData;
1360 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1363 consumeError(MaybeKind.takeError());
1366 unsigned Kind = MaybeKind.get();
1370 if (GlobalVariableTable)
1373 uint32_t tableOffset;
1374 global_variable_block::GlobalVariableDataLayout::readRecord(Scratch,
1376 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1378 GlobalVariableTable.reset(SerializedGlobalVariableTable::Create(
1379 base + tableOffset, base +
sizeof(uint32_t), base));
1389 MaybeNext = Cursor.advance();
1392 consumeError(MaybeNext.takeError());
1395 Next = MaybeNext.get();
1409 consumeError(MaybeNext.takeError());
1412 llvm::BitstreamEntry Next = MaybeNext.get();
1413 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1414 if (Next.Kind == llvm::BitstreamEntry::Error)
1417 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1420 if (Cursor.SkipBlock())
1423 MaybeNext = Cursor.advance();
1426 consumeError(MaybeNext.takeError());
1429 Next = MaybeNext.get();
1434 llvm::StringRef BlobData;
1436 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1439 consumeError(MaybeKind.takeError());
1442 unsigned Kind = MaybeKind.get();
1446 if (GlobalFunctionTable)
1449 uint32_t tableOffset;
1450 global_function_block::GlobalFunctionDataLayout::readRecord(Scratch,
1452 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1454 GlobalFunctionTable.reset(SerializedGlobalFunctionTable::Create(
1455 base + tableOffset, base +
sizeof(uint32_t), base));
1465 MaybeNext = Cursor.advance();
1468 consumeError(MaybeNext.takeError());
1471 Next = MaybeNext.get();
1485 consumeError(MaybeNext.takeError());
1488 llvm::BitstreamEntry Next = MaybeNext.get();
1489 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1490 if (Next.Kind == llvm::BitstreamEntry::Error)
1493 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1496 if (Cursor.SkipBlock())
1499 MaybeNext = Cursor.advance();
1502 consumeError(MaybeNext.takeError());
1505 Next = MaybeNext.get();
1510 llvm::StringRef BlobData;
1512 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1515 consumeError(MaybeKind.takeError());
1518 unsigned Kind = MaybeKind.get();
1522 if (EnumConstantTable)
1525 uint32_t tableOffset;
1526 enum_constant_block::EnumConstantDataLayout::readRecord(Scratch,
1528 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1530 EnumConstantTable.reset(SerializedEnumConstantTable::Create(
1531 base + tableOffset, base +
sizeof(uint32_t), base));
1541 MaybeNext = Cursor.advance();
1544 consumeError(MaybeNext.takeError());
1547 Next = MaybeNext.get();
1561 consumeError(MaybeNext.takeError());
1564 llvm::BitstreamEntry Next = MaybeNext.get();
1565 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1566 if (Next.Kind == llvm::BitstreamEntry::Error)
1569 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1572 if (Cursor.SkipBlock())
1575 MaybeNext = Cursor.advance();
1578 consumeError(MaybeNext.takeError());
1581 Next = MaybeNext.get();
1586 llvm::StringRef BlobData;
1588 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1591 consumeError(MaybeKind.takeError());
1594 unsigned Kind = MaybeKind.get();
1601 uint32_t tableOffset;
1602 tag_block::TagDataLayout::readRecord(Scratch, tableOffset);
1603 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1605 TagTable.reset(SerializedTagTable::Create(base + tableOffset,
1606 base +
sizeof(uint32_t), base));
1616 MaybeNext = Cursor.advance();
1619 consumeError(MaybeNext.takeError());
1622 Next = MaybeNext.get();
1636 consumeError(MaybeNext.takeError());
1639 llvm::BitstreamEntry Next = MaybeNext.get();
1640 while (Next.Kind != llvm::BitstreamEntry::EndBlock) {
1641 if (Next.Kind == llvm::BitstreamEntry::Error)
1644 if (Next.Kind == llvm::BitstreamEntry::SubBlock) {
1647 if (Cursor.SkipBlock())
1650 MaybeNext = Cursor.advance();
1653 consumeError(MaybeNext.takeError());
1656 Next = MaybeNext.get();
1661 llvm::StringRef BlobData;
1663 Cursor.readRecord(Next.ID, Scratch, &BlobData);
1666 consumeError(MaybeKind.takeError());
1669 unsigned Kind = MaybeKind.get();
1676 uint32_t tableOffset;
1677 typedef_block::TypedefDataLayout::readRecord(Scratch, tableOffset);
1678 auto base =
reinterpret_cast<const uint8_t *
>(BlobData.data());
1680 TypedefTable.reset(SerializedTypedefTable::Create(
1681 base + tableOffset, base +
sizeof(uint32_t), base));
1691 MaybeNext = Cursor.advance();
1694 consumeError(MaybeNext.takeError());
1697 Next = MaybeNext.get();
1703APINotesReader::APINotesReader(llvm::MemoryBuffer *InputBuffer,
1704 llvm::VersionTuple SwiftVersion,
bool &Failed)
1715 if (Cursor.AtEndOfStream()) {
1721 if (maybeRead.get() !=
byte) {
1727 consumeError(maybeRead.takeError());
1734 bool HasValidControlBlock =
false;
1736 while (!
Cursor.AtEndOfStream()) {
1738 if (!MaybeTopLevelEntry) {
1740 consumeError(MaybeTopLevelEntry.takeError());
1744 llvm::BitstreamEntry TopLevelEntry = MaybeTopLevelEntry.get();
1746 if (TopLevelEntry.Kind != llvm::BitstreamEntry::SubBlock)
1749 switch (TopLevelEntry.ID) {
1750 case llvm::bitc::BLOCKINFO_BLOCK_ID:
1751 if (!
Cursor.ReadBlockInfoBlock()) {
1759 if (HasValidControlBlock ||
1760 Implementation->readControlBlock(Cursor, Scratch)) {
1765 HasValidControlBlock =
true;
1769 if (!HasValidControlBlock ||
1770 Implementation->readIdentifierBlock(Cursor, Scratch)) {
1777 if (!HasValidControlBlock ||
1778 Implementation->readContextBlock(Cursor, Scratch)) {
1786 if (!HasValidControlBlock ||
1787 Implementation->readObjCPropertyBlock(Cursor, Scratch)) {
1794 if (!HasValidControlBlock ||
1795 Implementation->readObjCMethodBlock(Cursor, Scratch)) {
1802 if (!HasValidControlBlock ||
1803 Implementation->readCXXMethodBlock(Cursor, Scratch)) {
1810 if (!HasValidControlBlock ||
1811 Implementation->readObjCSelectorBlock(Cursor, Scratch)) {
1818 if (!HasValidControlBlock ||
1819 Implementation->readGlobalVariableBlock(Cursor, Scratch)) {
1826 if (!HasValidControlBlock ||
1827 Implementation->readGlobalFunctionBlock(Cursor, Scratch)) {
1834 if (!HasValidControlBlock ||
1835 Implementation->readEnumConstantBlock(Cursor, Scratch)) {
1842 if (!HasValidControlBlock ||
1843 Implementation->readTagBlock(Cursor, Scratch)) {
1850 if (!HasValidControlBlock ||
1851 Implementation->readTypedefBlock(Cursor, Scratch)) {
1860 if (
Cursor.SkipBlock()) {
1868 if (!
Cursor.AtEndOfStream()) {
1876std::unique_ptr<APINotesReader>
1878 llvm::VersionTuple SwiftVersion) {
1879 bool Failed =
false;
1880 std::unique_ptr<APINotesReader> Reader(
1881 new APINotesReader(InputBuffer.release(), SwiftVersion, Failed));
1888template <
typename T>
1890 llvm::VersionTuple Version,
1892 : Results(
std::move(R)) {
1894 assert(!Results.empty());
1895 assert(std::is_sorted(
1896 Results.begin(), Results.end(),
1897 [](
const std::pair<llvm::VersionTuple, T> &left,
1898 const std::pair<llvm::VersionTuple, T> &right) ->
bool {
1899 assert(left.first != right.first &&
"two entries for the same version");
1900 return left.first < right.first;
1903 Selected = std::nullopt;
1904 for (
unsigned i = 0, n = Results.size(); i != n; ++i) {
1905 if (!Version.empty() && Results[i].first >= Version) {
1917 if (!Selected && Results[0].first.empty())
1922 -> std::optional<ContextID> {
1924 return std::nullopt;
1928 return std::nullopt;
1935 return std::nullopt;
1943 return std::nullopt;
1947 return std::nullopt;
1951 return std::nullopt;
1957 -> std::optional<ContextID> {
1959 return std::nullopt;
1963 return std::nullopt;
1970 return std::nullopt;
1978 return std::nullopt;
1982 return std::nullopt;
1986 return std::nullopt;
1995 return std::nullopt;
1999 return std::nullopt;
2002 std::make_tuple(CtxID.Value, *PropertyID, (
char)IsInstance));
2004 return std::nullopt;
2010 bool IsInstanceMethod)
2013 return std::nullopt;
2017 return std::nullopt;
2020 ObjCMethodTableInfo::internal_key_type{CtxID.Value, *SelID,
2023 return std::nullopt;
2031 return std::nullopt;
2035 return std::nullopt;
2040 return std::nullopt;
2046 std::optional<Context> Ctx)
2049 return std::nullopt;
2053 return std::nullopt;
2059 return std::nullopt;
2065 std::optional<Context> Ctx)
2068 return std::nullopt;
2072 return std::nullopt;
2078 return std::nullopt;
2086 return std::nullopt;
2090 return std::nullopt;
2094 return std::nullopt;
2100 std::optional<Context> ParentCtx)
2101 -> std::optional<ContextID> {
2103 return std::nullopt;
2107 return std::nullopt;
2112 return std::nullopt;
2120 return std::nullopt;
2124 return std::nullopt;
2130 return std::nullopt;
2136 std::optional<Context> Ctx)
2139 return std::nullopt;
2143 return std::nullopt;
2149 return std::nullopt;
2155 llvm::StringRef Name, std::optional<ContextID> ParentNamespaceID)
2156 -> std::optional<ContextID> {
2158 return std::nullopt;
2162 return std::nullopt;
2164 uint32_t RawParentNamespaceID =
2165 ParentNamespaceID ? ParentNamespaceID->Value : -1;
2169 return std::nullopt;
static StringRef getIdentifier(const Token &Tok)
Implements an efficient mapping from strings to IdentifierInfo nodes.
iterator find(StringRef Name) const
Smart pointer class that efficiently represents Objective-C method names.
llvm::OnDiskIterableChainedHashTable< GlobalVariableTableInfo > SerializedGlobalVariableTable
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
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)
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.
llvm::OnDiskIterableChainedHashTable< ObjCSelectorTableInfo > SerializedObjCSelectorTable
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.
bool readControlBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
std::unique_ptr< SerializedCXXMethodTable > CXXMethodTable
The C++ method table.
bool readObjCPropertyBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readObjCSelectorBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::OnDiskIterableChainedHashTable< IdentifierTableInfo > SerializedIdentifierTable
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)
llvm::OnDiskIterableChainedHashTable< ObjCPropertyTableInfo > SerializedObjCPropertyTable
std::unique_ptr< SerializedTagTable > TagTable
The tag table.
llvm::OnDiskIterableChainedHashTable< CXXMethodTableInfo > SerializedCXXMethodTable
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< ObjCMethodTableInfo > SerializedObjCMethodTable
bool readCXXMethodBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
bool readIdentifierBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::VersionTuple SwiftVersion
The Swift version to use for filtering.
bool readContextBlock(llvm::BitstreamCursor &Cursor, llvm::SmallVectorImpl< uint64_t > &Scratch)
llvm::OnDiskIterableChainedHashTable< EnumConstantTableInfo > SerializedEnumConstantTable
std::unique_ptr< SerializedObjCMethodTable > ObjCMethodTable
The Objective-C method table.
std::unique_ptr< SerializedContextInfoTable > ContextInfoTable
The Objective-C context info table.
llvm::OnDiskIterableChainedHashTable< TypedefTableInfo > SerializedTypedefTable
llvm::OnDiskIterableChainedHashTable< GlobalFunctionTableInfo > SerializedGlobalFunctionTable
llvm::OnDiskIterableChainedHashTable< ContextInfoTableInfo > SerializedContextInfoTable
llvm::OnDiskIterableChainedHashTable< ContextIDTableInfo > SerializedContextIDTable
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.
A class that reads API notes data from a binary file that was written by the APINotesWriter.
VersionedInfo< ContextInfo > lookupObjCClassInfo(llvm::StringRef Name)
Look for information regarding the given Objective-C class.
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.
Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace.
llvm::PointerEmbeddedInt< unsigned, 31 > SelectorID
const uint8_t kSwiftCopyable
RetainCountConventionKind
llvm::PointerEmbeddedInt< unsigned, 31 > IdentifierID
SwiftNewTypeKind
The kind of a swift_wrapper/swift_newtype.
const uint8_t kSwiftNonCopyable
EnumExtensibilityKind
The payload for an enum_extensibility attribute.
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,...
@ 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