1//===-- APINotesWriter.cpp - API Notes Writer -------------------*- 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/APINotesWriter.h"
10#include "APINotesFormat.h"
11#include "clang/APINotes/Types.h"
12#include "clang/Basic/FileManager.h"
13#include "llvm/ADT/DenseMap.h"
14#include "llvm/ADT/StringMap.h"
15#include "llvm/Bitstream/BitstreamWriter.h"
16#include "llvm/Support/DJB.h"
17#include "llvm/Support/OnDiskHashTable.h"
18#include "llvm/Support/VersionTuple.h"
19
20namespace clang {
21namespace api_notes {
22class APINotesWriter::Implementation {
23 friend class APINotesWriter;
24
25 template <typename T>
26 using VersionedSmallVector =
27 llvm::SmallVector<std::pair<llvm::VersionTuple, T>, 1>;
28
29 std::string ModuleName;
30 const FileEntry *SourceFile;
31
32 /// Scratch space for bitstream writing.
33 llvm::SmallVector<uint64_t, 64> Scratch;
34
35 /// Mapping from strings to identifier IDs.
36 llvm::StringMap<IdentifierID> IdentifierIDs;
37
38 /// Information about contexts (Objective-C classes or protocols or C++
39 /// namespaces).
40 ///
41 /// Indexed by the parent context ID, context kind and the identifier ID of
42 /// this context and provides both the context ID and information describing
43 /// the context within that module.
44 llvm::DenseMap<ContextTableKey,
45 std::pair<unsigned, VersionedSmallVector<ContextInfo>>>
46 Contexts;
47
48 /// Information about parent contexts for each context.
49 ///
50 /// Indexed by context ID, provides the parent context ID.
51 llvm::DenseMap<uint32_t, uint32_t> ParentContexts;
52
53 /// Mapping from context IDs to the kind of context.
54 llvm::DenseMap<unsigned, uint8_t> ContextKinds;
55
56 /// Mapping from context IDs to the identifier ID holding the name.
57 llvm::DenseMap<unsigned, unsigned> ContextNames;
58
59 /// Information about Objective-C properties.
60 ///
61 /// Indexed by the context ID, property name, and whether this is an
62 /// instance property.
63 llvm::DenseMap<
64 std::tuple<unsigned, unsigned, char>,
65 llvm::SmallVector<std::pair<VersionTuple, ObjCPropertyInfo>, 1>>
66 ObjCProperties;
67
68 /// Information about C record fields.
69 ///
70 /// Indexed by the context ID and name ID.
71 llvm::DenseMap<SingleDeclTableKey,
72 llvm::SmallVector<std::pair<VersionTuple, FieldInfo>, 1>>
73 Fields;
74
75 /// Information about Objective-C methods.
76 ///
77 /// Indexed by the context ID, selector ID, and Boolean (stored as a char)
78 /// indicating whether this is a class or instance method.
79 llvm::DenseMap<std::tuple<unsigned, unsigned, char>,
80 llvm::SmallVector<std::pair<VersionTuple, ObjCMethodInfo>, 1>>
81 ObjCMethods;
82
83 /// Information about C++ methods.
84 ///
85 /// Indexed by the context ID and name ID.
86 llvm::DenseMap<SingleDeclTableKey,
87 llvm::SmallVector<std::pair<VersionTuple, CXXMethodInfo>, 1>>
88 CXXMethods;
89
90 /// Mapping from selectors to selector ID.
91 llvm::DenseMap<StoredObjCSelector, SelectorID> SelectorIDs;
92
93 /// Information about global variables.
94 ///
95 /// Indexed by the context ID, identifier ID.
96 llvm::DenseMap<
97 SingleDeclTableKey,
98 llvm::SmallVector<std::pair<VersionTuple, GlobalVariableInfo>, 1>>
99 GlobalVariables;
100
101 /// Information about global functions.
102 ///
103 /// Indexed by the context ID, identifier ID.
104 llvm::DenseMap<
105 SingleDeclTableKey,
106 llvm::SmallVector<std::pair<VersionTuple, GlobalFunctionInfo>, 1>>
107 GlobalFunctions;
108
109 /// Information about enumerators.
110 ///
111 /// Indexed by the identifier ID.
112 llvm::DenseMap<
113 unsigned, llvm::SmallVector<std::pair<VersionTuple, EnumConstantInfo>, 1>>
114 EnumConstants;
115
116 /// Information about tags.
117 ///
118 /// Indexed by the context ID, identifier ID.
119 llvm::DenseMap<SingleDeclTableKey,
120 llvm::SmallVector<std::pair<VersionTuple, TagInfo>, 1>>
121 Tags;
122
123 /// Information about typedefs.
124 ///
125 /// Indexed by the context ID, identifier ID.
126 llvm::DenseMap<SingleDeclTableKey,
127 llvm::SmallVector<std::pair<VersionTuple, TypedefInfo>, 1>>
128 Typedefs;
129
130 /// Retrieve the ID for the given identifier.
131 IdentifierID getIdentifier(StringRef Identifier) {
132 if (Identifier.empty())
133 return 0;
134
135 // Add to the identifier table if missing.
136 return IdentifierIDs.try_emplace(Key: Identifier, Args: IdentifierIDs.size() + 1)
137 .first->second;
138 }
139
140 /// Retrieve the ID for the given selector.
141 SelectorID getSelector(ObjCSelectorRef SelectorRef) {
142 // Translate the selector reference into a stored selector.
143 StoredObjCSelector Selector;
144 Selector.NumArgs = SelectorRef.NumArgs;
145 Selector.Identifiers.reserve(N: SelectorRef.Identifiers.size());
146 for (auto piece : SelectorRef.Identifiers)
147 Selector.Identifiers.push_back(Elt: getIdentifier(Identifier: piece));
148
149 // Look for the stored selector. Add to the selector table if missing.
150 return SelectorIDs.try_emplace(Key: Selector, Args: SelectorIDs.size()).first->second;
151 }
152
153private:
154 void writeBlockInfoBlock(llvm::BitstreamWriter &Stream);
155 void writeControlBlock(llvm::BitstreamWriter &Stream);
156 void writeIdentifierBlock(llvm::BitstreamWriter &Stream);
157 void writeContextBlock(llvm::BitstreamWriter &Stream);
158 void writeObjCPropertyBlock(llvm::BitstreamWriter &Stream);
159 void writeObjCMethodBlock(llvm::BitstreamWriter &Stream);
160 void writeCXXMethodBlock(llvm::BitstreamWriter &Stream);
161 void writeFieldBlock(llvm::BitstreamWriter &Stream);
162 void writeObjCSelectorBlock(llvm::BitstreamWriter &Stream);
163 void writeGlobalVariableBlock(llvm::BitstreamWriter &Stream);
164 void writeGlobalFunctionBlock(llvm::BitstreamWriter &Stream);
165 void writeEnumConstantBlock(llvm::BitstreamWriter &Stream);
166 void writeTagBlock(llvm::BitstreamWriter &Stream);
167 void writeTypedefBlock(llvm::BitstreamWriter &Stream);
168
169public:
170 Implementation(llvm::StringRef ModuleName, const FileEntry *SF)
171 : ModuleName(std::string(ModuleName)), SourceFile(SF) {}
172
173 void writeToStream(llvm::raw_ostream &OS);
174};
175
176void APINotesWriter::Implementation::writeToStream(llvm::raw_ostream &OS) {
177 llvm::SmallVector<char, 0> Buffer;
178
179 {
180 llvm::BitstreamWriter Stream(Buffer);
181
182 // Emit the signature.
183 for (unsigned char Byte : API_NOTES_SIGNATURE)
184 Stream.Emit(Val: Byte, NumBits: 8);
185
186 // Emit the blocks.
187 writeBlockInfoBlock(Stream);
188 writeControlBlock(Stream);
189 writeIdentifierBlock(Stream);
190 writeContextBlock(Stream);
191 writeObjCPropertyBlock(Stream);
192 writeObjCMethodBlock(Stream);
193 writeCXXMethodBlock(Stream);
194 writeFieldBlock(Stream);
195 writeObjCSelectorBlock(Stream);
196 writeGlobalVariableBlock(Stream);
197 writeGlobalFunctionBlock(Stream);
198 writeEnumConstantBlock(Stream);
199 writeTagBlock(Stream);
200 writeTypedefBlock(Stream);
201 }
202
203 OS.write(Ptr: Buffer.data(), Size: Buffer.size());
204 OS.flush();
205}
206
207namespace {
208/// Record the name of a block.
209void emitBlockID(llvm::BitstreamWriter &Stream, unsigned ID,
210 llvm::StringRef Name) {
211 Stream.EmitRecord(Code: llvm::bitc::BLOCKINFO_CODE_SETBID,
212 Vals: llvm::ArrayRef<unsigned>{ID});
213
214 // Emit the block name if present.
215 if (Name.empty())
216 return;
217 Stream.EmitRecord(
218 Code: llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
219 Vals: llvm::ArrayRef<unsigned char>(
220 const_cast<unsigned char *>(
221 reinterpret_cast<const unsigned char *>(Name.data())),
222 Name.size()));
223}
224
225/// Record the name of a record within a block.
226void emitRecordID(llvm::BitstreamWriter &Stream, unsigned ID,
227 llvm::StringRef Name) {
228 assert(ID < 256 && "can't fit record ID in next to name");
229
230 llvm::SmallVector<unsigned char, 64> Buffer;
231 Buffer.resize(N: Name.size() + 1);
232 Buffer[0] = ID;
233 memcpy(dest: Buffer.data() + 1, src: Name.data(), n: Name.size());
234
235 Stream.EmitRecord(Code: llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Vals: Buffer);
236}
237} // namespace
238
239void APINotesWriter::Implementation::writeBlockInfoBlock(
240 llvm::BitstreamWriter &Stream) {
241 llvm::BCBlockRAII Scope(Stream, llvm::bitc::BLOCKINFO_BLOCK_ID, 2);
242
243#define BLOCK(Block) emitBlockID(Stream, Block##_ID, #Block)
244#define BLOCK_RECORD(NameSpace, Block) \
245 emitRecordID(Stream, NameSpace::Block, #Block)
246 BLOCK(CONTROL_BLOCK);
247 BLOCK_RECORD(control_block, METADATA);
248 BLOCK_RECORD(control_block, MODULE_NAME);
249
250 BLOCK(IDENTIFIER_BLOCK);
251 BLOCK_RECORD(identifier_block, IDENTIFIER_DATA);
252
253 BLOCK(OBJC_CONTEXT_BLOCK);
254 BLOCK_RECORD(context_block, CONTEXT_ID_DATA);
255
256 BLOCK(OBJC_PROPERTY_BLOCK);
257 BLOCK_RECORD(objc_property_block, OBJC_PROPERTY_DATA);
258
259 BLOCK(OBJC_METHOD_BLOCK);
260 BLOCK_RECORD(objc_method_block, OBJC_METHOD_DATA);
261
262 BLOCK(OBJC_SELECTOR_BLOCK);
263 BLOCK_RECORD(objc_selector_block, OBJC_SELECTOR_DATA);
264
265 BLOCK(GLOBAL_VARIABLE_BLOCK);
266 BLOCK_RECORD(global_variable_block, GLOBAL_VARIABLE_DATA);
267
268 BLOCK(GLOBAL_FUNCTION_BLOCK);
269 BLOCK_RECORD(global_function_block, GLOBAL_FUNCTION_DATA);
270#undef BLOCK_RECORD
271#undef BLOCK
272}
273
274void APINotesWriter::Implementation::writeControlBlock(
275 llvm::BitstreamWriter &Stream) {
276 llvm::BCBlockRAII Scope(Stream, CONTROL_BLOCK_ID, 3);
277
278 control_block::MetadataLayout Metadata(Stream);
279 Metadata.emit(buffer&: Scratch, data: VERSION_MAJOR, data: VERSION_MINOR);
280
281 control_block::ModuleNameLayout ModuleName(Stream);
282 ModuleName.emit(buffer&: Scratch, data&: this->ModuleName);
283
284 if (SourceFile) {
285 control_block::SourceFileLayout SourceFile(Stream);
286 SourceFile.emit(buffer&: Scratch, data: this->SourceFile->getSize(),
287 data: this->SourceFile->getModificationTime());
288 }
289}
290
291namespace {
292/// Used to serialize the on-disk identifier table.
293class IdentifierTableInfo {
294public:
295 using key_type = StringRef;
296 using key_type_ref = key_type;
297 using data_type = IdentifierID;
298 using data_type_ref = const data_type &;
299 using hash_value_type = uint32_t;
300 using offset_type = unsigned;
301
302 hash_value_type ComputeHash(key_type_ref Key) { return llvm::djbHash(Buffer: Key); }
303
304 std::pair<unsigned, unsigned>
305 EmitKeyDataLength(raw_ostream &OS, key_type_ref Key, data_type_ref) {
306 uint32_t KeyLength = Key.size();
307 uint32_t DataLength = sizeof(uint32_t);
308
309 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
310 writer.write<uint16_t>(Val: KeyLength);
311 writer.write<uint16_t>(Val: DataLength);
312 return {KeyLength, DataLength};
313 }
314
315 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) { OS << Key; }
316
317 void EmitData(raw_ostream &OS, key_type_ref, data_type_ref Data, unsigned) {
318 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
319 writer.write<uint32_t>(Val: Data);
320 }
321};
322} // namespace
323
324void APINotesWriter::Implementation::writeIdentifierBlock(
325 llvm::BitstreamWriter &Stream) {
326 llvm::BCBlockRAII restoreBlock(Stream, IDENTIFIER_BLOCK_ID, 3);
327
328 if (IdentifierIDs.empty())
329 return;
330
331 llvm::SmallString<4096> HashTableBlob;
332 uint32_t Offset;
333 {
334 llvm::OnDiskChainedHashTableGenerator<IdentifierTableInfo> Generator;
335 for (auto &II : IdentifierIDs)
336 Generator.insert(Key: II.first(), Data: II.second);
337
338 llvm::raw_svector_ostream BlobStream(HashTableBlob);
339 // Make sure that no bucket is at offset 0
340 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
341 endian: llvm::endianness::little);
342 Offset = Generator.Emit(Out&: BlobStream);
343 }
344
345 identifier_block::IdentifierDataLayout IdentifierData(Stream);
346 IdentifierData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
347}
348
349namespace {
350/// Used to serialize the on-disk Objective-C context table.
351class ContextIDTableInfo {
352public:
353 using key_type = ContextTableKey;
354 using key_type_ref = key_type;
355 using data_type = unsigned;
356 using data_type_ref = const data_type &;
357 using hash_value_type = size_t;
358 using offset_type = unsigned;
359
360 hash_value_type ComputeHash(key_type_ref Key) {
361 return static_cast<size_t>(Key.hashValue());
362 }
363
364 std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &OS, key_type_ref,
365 data_type_ref) {
366 uint32_t KeyLength = sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint32_t);
367 uint32_t DataLength = sizeof(uint32_t);
368
369 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
370 writer.write<uint16_t>(Val: KeyLength);
371 writer.write<uint16_t>(Val: DataLength);
372 return {KeyLength, DataLength};
373 }
374
375 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
376 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
377 writer.write<uint32_t>(Val: Key.parentContextID);
378 writer.write<uint8_t>(Val: Key.contextKind);
379 writer.write<uint32_t>(Val: Key.contextID);
380 }
381
382 void EmitData(raw_ostream &OS, key_type_ref, data_type_ref Data, unsigned) {
383 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
384 writer.write<uint32_t>(Val: Data);
385 }
386};
387
388/// Localized helper to make a type dependent, thwarting template argument
389/// deduction.
390template <typename T> struct MakeDependent { typedef T Type; };
391
392/// Retrieve the serialized size of the given VersionTuple, for use in
393/// on-disk hash tables.
394unsigned getVersionTupleSize(const VersionTuple &VT) {
395 unsigned size = sizeof(uint8_t) + /*major*/ sizeof(uint32_t);
396 if (VT.getMinor())
397 size += sizeof(uint32_t);
398 if (VT.getSubminor())
399 size += sizeof(uint32_t);
400 if (VT.getBuild())
401 size += sizeof(uint32_t);
402 return size;
403}
404
405/// Determine the size of an array of versioned information,
406template <typename T>
407unsigned getVersionedInfoSize(
408 const llvm::SmallVectorImpl<std::pair<llvm::VersionTuple, T>> &VI,
409 llvm::function_ref<unsigned(const typename MakeDependent<T>::Type &)>
410 getInfoSize) {
411 unsigned result = sizeof(uint16_t); // # of elements
412 for (const auto &E : VI) {
413 result += getVersionTupleSize(E.first);
414 result += getInfoSize(E.second);
415 }
416 return result;
417}
418
419/// Emit a serialized representation of a version tuple.
420void emitVersionTuple(raw_ostream &OS, const VersionTuple &VT) {
421 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
422
423 // First byte contains the number of components beyond the 'major' component.
424 uint8_t descriptor;
425 if (VT.getBuild())
426 descriptor = 3;
427 else if (VT.getSubminor())
428 descriptor = 2;
429 else if (VT.getMinor())
430 descriptor = 1;
431 else
432 descriptor = 0;
433 writer.write<uint8_t>(Val: descriptor);
434
435 // Write the components.
436 writer.write<uint32_t>(Val: VT.getMajor());
437 if (auto minor = VT.getMinor())
438 writer.write<uint32_t>(Val: *minor);
439 if (auto subminor = VT.getSubminor())
440 writer.write<uint32_t>(Val: *subminor);
441 if (auto build = VT.getBuild())
442 writer.write<uint32_t>(Val: *build);
443}
444
445/// Emit versioned information.
446template <typename T>
447void emitVersionedInfo(
448 raw_ostream &OS, llvm::SmallVectorImpl<std::pair<VersionTuple, T>> &VI,
449 llvm::function_ref<void(raw_ostream &,
450 const typename MakeDependent<T>::Type &)>
451 emitInfo) {
452 std::sort(VI.begin(), VI.end(),
453 [](const std::pair<VersionTuple, T> &LHS,
454 const std::pair<VersionTuple, T> &RHS) -> bool {
455 assert((&LHS == &RHS || LHS.first != RHS.first) &&
456 "two entries for the same version");
457 return LHS.first < RHS.first;
458 });
459
460 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
461 writer.write<uint16_t>(VI.size());
462 for (const auto &E : VI) {
463 emitVersionTuple(OS, E.first);
464 emitInfo(OS, E.second);
465 }
466}
467
468/// On-disk hash table info key base for handling versioned data.
469template <typename Derived, typename KeyType, typename UnversionedDataType>
470class VersionedTableInfo {
471 Derived &asDerived() { return *static_cast<Derived *>(this); }
472
473 const Derived &asDerived() const {
474 return *static_cast<const Derived *>(this);
475 }
476
477public:
478 using key_type = KeyType;
479 using key_type_ref = key_type;
480 using data_type =
481 llvm::SmallVector<std::pair<llvm::VersionTuple, UnversionedDataType>, 1>;
482 using data_type_ref = data_type &;
483 using hash_value_type = size_t;
484 using offset_type = unsigned;
485
486 std::pair<unsigned, unsigned>
487 EmitKeyDataLength(raw_ostream &OS, key_type_ref Key, data_type_ref Data) {
488 uint32_t KeyLength = asDerived().getKeyLength(Key);
489 uint32_t DataLength =
490 getVersionedInfoSize(Data, [this](const UnversionedDataType &UI) {
491 return asDerived().getUnversionedInfoSize(UI);
492 });
493
494 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
495 writer.write<uint16_t>(Val: KeyLength);
496 writer.write<uint16_t>(Val: DataLength);
497 return {KeyLength, DataLength};
498 }
499
500 void EmitData(raw_ostream &OS, key_type_ref, data_type_ref Data, unsigned) {
501 emitVersionedInfo(
502 OS, Data, [this](llvm::raw_ostream &OS, const UnversionedDataType &UI) {
503 asDerived().emitUnversionedInfo(OS, UI);
504 });
505 }
506};
507
508/// Emit a serialized representation of the common entity information.
509void emitCommonEntityInfo(raw_ostream &OS, const CommonEntityInfo &CEI) {
510 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
511
512 uint8_t payload = 0;
513 if (auto safety = CEI.getSwiftSafety()) {
514 payload = static_cast<unsigned>(*safety);
515 payload <<= 1;
516 payload |= 0x01;
517 }
518 payload <<= 2;
519 if (auto swiftPrivate = CEI.isSwiftPrivate()) {
520 payload |= 0x01;
521 if (*swiftPrivate)
522 payload |= 0x02;
523 }
524 payload <<= 1;
525 payload |= CEI.Unavailable;
526 payload <<= 1;
527 payload |= CEI.UnavailableInSwift;
528
529 writer.write<uint8_t>(Val: payload);
530
531 writer.write<uint16_t>(Val: CEI.UnavailableMsg.size());
532 OS.write(Ptr: CEI.UnavailableMsg.c_str(), Size: CEI.UnavailableMsg.size());
533
534 writer.write<uint16_t>(Val: CEI.SwiftName.size());
535 OS.write(Ptr: CEI.SwiftName.c_str(), Size: CEI.SwiftName.size());
536}
537
538/// Retrieve the serialized size of the given CommonEntityInfo, for use in
539/// on-disk hash tables.
540unsigned getCommonEntityInfoSize(const CommonEntityInfo &CEI) {
541 return 5 + CEI.UnavailableMsg.size() + CEI.SwiftName.size();
542}
543
544// Retrieve the serialized size of the given CommonTypeInfo, for use
545// in on-disk hash tables.
546unsigned getCommonTypeInfoSize(const CommonTypeInfo &CTI) {
547 return 2 + (CTI.getSwiftBridge() ? CTI.getSwiftBridge()->size() : 0) + 2 +
548 (CTI.getNSErrorDomain() ? CTI.getNSErrorDomain()->size() : 0) + 2 +
549 (CTI.getSwiftConformance() ? CTI.getSwiftConformance()->size() : 0) +
550 getCommonEntityInfoSize(CEI: CTI);
551}
552
553/// Emit a serialized representation of the common type information.
554void emitCommonTypeInfo(raw_ostream &OS, const CommonTypeInfo &CTI) {
555 emitCommonEntityInfo(OS, CEI: CTI);
556
557 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
558 if (auto swiftBridge = CTI.getSwiftBridge()) {
559 writer.write<uint16_t>(Val: swiftBridge->size() + 1);
560 OS.write(Ptr: swiftBridge->c_str(), Size: swiftBridge->size());
561 } else {
562 writer.write<uint16_t>(Val: 0);
563 }
564 if (auto nsErrorDomain = CTI.getNSErrorDomain()) {
565 writer.write<uint16_t>(Val: nsErrorDomain->size() + 1);
566 OS.write(Ptr: nsErrorDomain->c_str(), Size: CTI.getNSErrorDomain()->size());
567 } else {
568 writer.write<uint16_t>(Val: 0);
569 }
570 if (auto conformance = CTI.getSwiftConformance()) {
571 writer.write<uint16_t>(Val: conformance->size() + 1);
572 OS.write(Ptr: conformance->c_str(), Size: conformance->size());
573 } else {
574 writer.write<uint16_t>(Val: 0);
575 }
576}
577
578/// Used to serialize the on-disk Objective-C property table.
579class ContextInfoTableInfo
580 : public VersionedTableInfo<ContextInfoTableInfo, unsigned, ContextInfo> {
581public:
582 unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
583
584 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
585 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
586 writer.write<uint32_t>(Val: Key);
587 }
588
589 hash_value_type ComputeHash(key_type_ref Key) {
590 return static_cast<size_t>(llvm::hash_value(value: Key));
591 }
592
593 unsigned getUnversionedInfoSize(const ContextInfo &OCI) {
594 return getCommonTypeInfoSize(CTI: OCI) + 1;
595 }
596
597 void emitUnversionedInfo(raw_ostream &OS, const ContextInfo &OCI) {
598 emitCommonTypeInfo(OS, CTI: OCI);
599
600 uint8_t payload = 0;
601 if (auto swiftImportAsNonGeneric = OCI.getSwiftImportAsNonGeneric())
602 payload |= (0x01 << 1) | (uint8_t)swiftImportAsNonGeneric.value();
603 payload <<= 2;
604 if (auto swiftObjCMembers = OCI.getSwiftObjCMembers())
605 payload |= (0x01 << 1) | (uint8_t)swiftObjCMembers.value();
606 payload <<= 3;
607 if (auto nullable = OCI.getDefaultNullability())
608 payload |= (0x01 << 2) | static_cast<uint8_t>(*nullable);
609 payload = (payload << 1) | (OCI.hasDesignatedInits() ? 1 : 0);
610
611 OS << payload;
612 }
613};
614} // namespace
615
616void APINotesWriter::Implementation::writeContextBlock(
617 llvm::BitstreamWriter &Stream) {
618 llvm::BCBlockRAII restoreBlock(Stream, OBJC_CONTEXT_BLOCK_ID, 3);
619
620 if (Contexts.empty())
621 return;
622
623 {
624 llvm::SmallString<4096> HashTableBlob;
625 uint32_t Offset;
626 {
627 llvm::OnDiskChainedHashTableGenerator<ContextIDTableInfo> Generator;
628 for (auto &OC : Contexts)
629 Generator.insert(Key: OC.first, Data: OC.second.first);
630
631 llvm::raw_svector_ostream BlobStream(HashTableBlob);
632 // Make sure that no bucket is at offset 0
633 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
634 endian: llvm::endianness::little);
635 Offset = Generator.Emit(Out&: BlobStream);
636 }
637
638 context_block::ContextIDLayout ContextID(Stream);
639 ContextID.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
640 }
641
642 {
643 llvm::SmallString<4096> HashTableBlob;
644 uint32_t Offset;
645 {
646 llvm::OnDiskChainedHashTableGenerator<ContextInfoTableInfo> Generator;
647 for (auto &OC : Contexts)
648 Generator.insert(Key: OC.second.first, Data&: OC.second.second);
649
650 llvm::raw_svector_ostream BlobStream(HashTableBlob);
651 // Make sure that no bucket is at offset 0
652 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
653 endian: llvm::endianness::little);
654 Offset = Generator.Emit(Out&: BlobStream);
655 }
656
657 context_block::ContextInfoLayout ContextInfo(Stream);
658 ContextInfo.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
659 }
660}
661
662namespace {
663/// Retrieve the serialized size of the given VariableInfo, for use in
664/// on-disk hash tables.
665unsigned getVariableInfoSize(const VariableInfo &VI) {
666 return 2 + getCommonEntityInfoSize(CEI: VI) + 2 + VI.getType().size();
667}
668unsigned getParamInfoSize(const ParamInfo &PI);
669
670/// Emit a serialized representation of the variable information.
671void emitVariableInfo(raw_ostream &OS, const VariableInfo &VI) {
672 emitCommonEntityInfo(OS, CEI: VI);
673
674 uint8_t bytes[2] = {0, 0};
675 if (auto nullable = VI.getNullability()) {
676 bytes[0] = 1;
677 bytes[1] = static_cast<uint8_t>(*nullable);
678 } else {
679 // Nothing to do.
680 }
681
682 OS.write(Ptr: reinterpret_cast<const char *>(bytes), Size: 2);
683
684 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
685 writer.write<uint16_t>(Val: VI.getType().size());
686 OS.write(Ptr: VI.getType().data(), Size: VI.getType().size());
687}
688
689/// Used to serialize the on-disk Objective-C property table.
690class ObjCPropertyTableInfo
691 : public VersionedTableInfo<ObjCPropertyTableInfo,
692 std::tuple<unsigned, unsigned, char>,
693 ObjCPropertyInfo> {
694public:
695 unsigned getKeyLength(key_type_ref) {
696 return sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
697 }
698
699 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
700 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
701 writer.write<uint32_t>(Val: std::get<0>(t&: Key));
702 writer.write<uint32_t>(Val: std::get<1>(t&: Key));
703 writer.write<uint8_t>(Val: std::get<2>(t&: Key));
704 }
705
706 hash_value_type ComputeHash(key_type_ref Key) {
707 return static_cast<size_t>(llvm::hash_value(arg: Key));
708 }
709
710 unsigned getUnversionedInfoSize(const ObjCPropertyInfo &OPI) {
711 return getVariableInfoSize(VI: OPI) + 1;
712 }
713
714 void emitUnversionedInfo(raw_ostream &OS, const ObjCPropertyInfo &OPI) {
715 emitVariableInfo(OS, VI: OPI);
716
717 uint8_t flags = 0;
718 if (auto value = OPI.getSwiftImportAsAccessors()) {
719 flags |= 1 << 0;
720 flags |= value.value() << 1;
721 }
722 OS << flags;
723 }
724};
725} // namespace
726
727void APINotesWriter::Implementation::writeObjCPropertyBlock(
728 llvm::BitstreamWriter &Stream) {
729 llvm::BCBlockRAII Scope(Stream, OBJC_PROPERTY_BLOCK_ID, 3);
730
731 if (ObjCProperties.empty())
732 return;
733
734 {
735 llvm::SmallString<4096> HashTableBlob;
736 uint32_t Offset;
737 {
738 llvm::OnDiskChainedHashTableGenerator<ObjCPropertyTableInfo> Generator;
739 for (auto &OP : ObjCProperties)
740 Generator.insert(Key: OP.first, Data&: OP.second);
741
742 llvm::raw_svector_ostream BlobStream(HashTableBlob);
743 // Make sure that no bucket is at offset 0
744 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
745 endian: llvm::endianness::little);
746 Offset = Generator.Emit(Out&: BlobStream);
747 }
748
749 objc_property_block::ObjCPropertyDataLayout ObjCPropertyData(Stream);
750 ObjCPropertyData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
751 }
752}
753
754namespace {
755unsigned getFunctionInfoSize(const FunctionInfo &);
756void emitFunctionInfo(llvm::raw_ostream &, const FunctionInfo &);
757void emitParamInfo(raw_ostream &OS, const ParamInfo &PI);
758
759/// Used to serialize the on-disk Objective-C method table.
760class ObjCMethodTableInfo
761 : public VersionedTableInfo<ObjCMethodTableInfo,
762 std::tuple<unsigned, unsigned, char>,
763 ObjCMethodInfo> {
764public:
765 unsigned getKeyLength(key_type_ref) {
766 return sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint8_t);
767 }
768
769 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
770 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
771 writer.write<uint32_t>(Val: std::get<0>(t&: Key));
772 writer.write<uint32_t>(Val: std::get<1>(t&: Key));
773 writer.write<uint8_t>(Val: std::get<2>(t&: Key));
774 }
775
776 hash_value_type ComputeHash(key_type_ref key) {
777 return static_cast<size_t>(llvm::hash_value(arg: key));
778 }
779
780 unsigned getUnversionedInfoSize(const ObjCMethodInfo &OMI) {
781 auto size = getFunctionInfoSize(OMI) + 1;
782 if (OMI.Self)
783 size += getParamInfoSize(PI: *OMI.Self);
784 return size;
785 }
786
787 void emitUnversionedInfo(raw_ostream &OS, const ObjCMethodInfo &OMI) {
788 uint8_t flags = 0;
789 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
790 flags = (flags << 1) | OMI.DesignatedInit;
791 flags = (flags << 1) | OMI.RequiredInit;
792 flags = (flags << 1) | static_cast<bool>(OMI.Self);
793 writer.write<uint8_t>(Val: flags);
794
795 emitFunctionInfo(OS, OMI);
796
797 if (OMI.Self)
798 emitParamInfo(OS, PI: *OMI.Self);
799 }
800};
801
802/// Used to serialize the on-disk C++ method table.
803class CXXMethodTableInfo
804 : public VersionedTableInfo<CXXMethodTableInfo, SingleDeclTableKey,
805 CXXMethodInfo> {
806public:
807 unsigned getKeyLength(key_type_ref) {
808 return sizeof(uint32_t) + sizeof(uint32_t);
809 }
810
811 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
812 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
813 writer.write<uint32_t>(Val: Key.parentContextID);
814 writer.write<uint32_t>(Val: Key.nameID);
815 }
816
817 hash_value_type ComputeHash(key_type_ref key) {
818 return static_cast<size_t>(key.hashValue());
819 }
820
821 unsigned getUnversionedInfoSize(const CXXMethodInfo &MI) {
822 auto size = getFunctionInfoSize(MI) + 1;
823 if (MI.This)
824 size += getParamInfoSize(PI: *MI.This);
825 return size;
826 }
827
828 void emitUnversionedInfo(raw_ostream &OS, const CXXMethodInfo &MI) {
829 uint8_t flags = 0;
830 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
831 flags = (flags << 1) | static_cast<bool>(MI.This);
832 writer.write<uint8_t>(Val: flags);
833
834 emitFunctionInfo(OS, MI);
835 if (MI.This)
836 emitParamInfo(OS, PI: *MI.This);
837 }
838};
839} // namespace
840
841void APINotesWriter::Implementation::writeObjCMethodBlock(
842 llvm::BitstreamWriter &Stream) {
843 llvm::BCBlockRAII Scope(Stream, OBJC_METHOD_BLOCK_ID, 3);
844
845 if (ObjCMethods.empty())
846 return;
847
848 {
849 llvm::SmallString<4096> HashTableBlob;
850 uint32_t Offset;
851 {
852 llvm::OnDiskChainedHashTableGenerator<ObjCMethodTableInfo> Generator;
853 for (auto &OM : ObjCMethods)
854 Generator.insert(Key: OM.first, Data&: OM.second);
855
856 llvm::raw_svector_ostream BlobStream(HashTableBlob);
857 // Make sure that no bucket is at offset 0
858 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
859 endian: llvm::endianness::little);
860 Offset = Generator.Emit(Out&: BlobStream);
861 }
862
863 objc_method_block::ObjCMethodDataLayout ObjCMethodData(Stream);
864 ObjCMethodData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
865 }
866}
867
868void APINotesWriter::Implementation::writeCXXMethodBlock(
869 llvm::BitstreamWriter &Stream) {
870 llvm::BCBlockRAII Scope(Stream, CXX_METHOD_BLOCK_ID, 3);
871
872 if (CXXMethods.empty())
873 return;
874
875 {
876 llvm::SmallString<4096> HashTableBlob;
877 uint32_t Offset;
878 {
879 llvm::OnDiskChainedHashTableGenerator<CXXMethodTableInfo> Generator;
880 for (auto &MD : CXXMethods)
881 Generator.insert(Key: MD.first, Data&: MD.second);
882
883 llvm::raw_svector_ostream BlobStream(HashTableBlob);
884 // Make sure that no bucket is at offset 0
885 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
886 endian: llvm::endianness::little);
887 Offset = Generator.Emit(Out&: BlobStream);
888 }
889
890 cxx_method_block::CXXMethodDataLayout CXXMethodData(Stream);
891 CXXMethodData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
892 }
893}
894
895namespace {
896/// Used to serialize the on-disk C field table.
897class FieldTableInfo
898 : public VersionedTableInfo<FieldTableInfo, SingleDeclTableKey, FieldInfo> {
899public:
900 unsigned getKeyLength(key_type_ref) {
901 return sizeof(uint32_t) + sizeof(uint32_t);
902 }
903
904 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
905 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
906 writer.write<uint32_t>(Val: Key.parentContextID);
907 writer.write<uint32_t>(Val: Key.nameID);
908 }
909
910 hash_value_type ComputeHash(key_type_ref key) {
911 return static_cast<size_t>(key.hashValue());
912 }
913
914 unsigned getUnversionedInfoSize(const FieldInfo &FI) {
915 return getVariableInfoSize(VI: FI);
916 }
917
918 void emitUnversionedInfo(raw_ostream &OS, const FieldInfo &FI) {
919 emitVariableInfo(OS, VI: FI);
920 }
921};
922} // namespace
923
924void APINotesWriter::Implementation::writeFieldBlock(
925 llvm::BitstreamWriter &Stream) {
926 llvm::BCBlockRAII Scope(Stream, FIELD_BLOCK_ID, 3);
927
928 if (Fields.empty())
929 return;
930
931 {
932 llvm::SmallString<4096> HashTableBlob;
933 uint32_t Offset;
934 {
935 llvm::OnDiskChainedHashTableGenerator<FieldTableInfo> Generator;
936 for (auto &FD : Fields)
937 Generator.insert(Key: FD.first, Data&: FD.second);
938
939 llvm::raw_svector_ostream BlobStream(HashTableBlob);
940 // Make sure that no bucket is at offset 0
941 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
942 endian: llvm::endianness::little);
943 Offset = Generator.Emit(Out&: BlobStream);
944 }
945
946 field_block::FieldDataLayout FieldData(Stream);
947 FieldData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
948 }
949}
950
951namespace {
952/// Used to serialize the on-disk Objective-C selector table.
953class ObjCSelectorTableInfo {
954public:
955 using key_type = StoredObjCSelector;
956 using key_type_ref = const key_type &;
957 using data_type = SelectorID;
958 using data_type_ref = data_type;
959 using hash_value_type = unsigned;
960 using offset_type = unsigned;
961
962 hash_value_type ComputeHash(key_type_ref Key) {
963 return llvm::DenseMapInfo<StoredObjCSelector>::getHashValue(Selector: Key);
964 }
965
966 std::pair<unsigned, unsigned>
967 EmitKeyDataLength(raw_ostream &OS, key_type_ref Key, data_type_ref) {
968 uint32_t KeyLength =
969 sizeof(uint16_t) + sizeof(uint32_t) * Key.Identifiers.size();
970 uint32_t DataLength = sizeof(uint32_t);
971
972 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
973 writer.write<uint16_t>(Val: KeyLength);
974 writer.write<uint16_t>(Val: DataLength);
975 return {KeyLength, DataLength};
976 }
977
978 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
979 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
980 writer.write<uint16_t>(Val: Key.NumArgs);
981 for (auto Identifier : Key.Identifiers)
982 writer.write<uint32_t>(Val: Identifier);
983 }
984
985 void EmitData(raw_ostream &OS, key_type_ref, data_type_ref Data, unsigned) {
986 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
987 writer.write<uint32_t>(Val: Data);
988 }
989};
990} // namespace
991
992void APINotesWriter::Implementation::writeObjCSelectorBlock(
993 llvm::BitstreamWriter &Stream) {
994 llvm::BCBlockRAII Scope(Stream, OBJC_SELECTOR_BLOCK_ID, 3);
995
996 if (SelectorIDs.empty())
997 return;
998
999 {
1000 llvm::SmallString<4096> HashTableBlob;
1001 uint32_t Offset;
1002 {
1003 llvm::OnDiskChainedHashTableGenerator<ObjCSelectorTableInfo> Generator;
1004 for (auto &S : SelectorIDs)
1005 Generator.insert(Key: S.first, Data: S.second);
1006
1007 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1008 // Make sure that no bucket is at offset 0
1009 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1010 endian: llvm::endianness::little);
1011 Offset = Generator.Emit(Out&: BlobStream);
1012 }
1013
1014 objc_selector_block::ObjCSelectorDataLayout ObjCSelectorData(Stream);
1015 ObjCSelectorData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1016 }
1017}
1018
1019namespace {
1020/// Used to serialize the on-disk global variable table.
1021class GlobalVariableTableInfo
1022 : public VersionedTableInfo<GlobalVariableTableInfo, SingleDeclTableKey,
1023 GlobalVariableInfo> {
1024public:
1025 unsigned getKeyLength(key_type_ref) {
1026 return sizeof(uint32_t) + sizeof(uint32_t);
1027 }
1028
1029 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
1030 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1031 writer.write<uint32_t>(Val: Key.parentContextID);
1032 writer.write<uint32_t>(Val: Key.nameID);
1033 }
1034
1035 hash_value_type ComputeHash(key_type_ref Key) {
1036 return static_cast<size_t>(Key.hashValue());
1037 }
1038
1039 unsigned getUnversionedInfoSize(const GlobalVariableInfo &GVI) {
1040 return getVariableInfoSize(VI: GVI);
1041 }
1042
1043 void emitUnversionedInfo(raw_ostream &OS, const GlobalVariableInfo &GVI) {
1044 emitVariableInfo(OS, VI: GVI);
1045 }
1046};
1047} // namespace
1048
1049void APINotesWriter::Implementation::writeGlobalVariableBlock(
1050 llvm::BitstreamWriter &Stream) {
1051 llvm::BCBlockRAII Scope(Stream, GLOBAL_VARIABLE_BLOCK_ID, 3);
1052
1053 if (GlobalVariables.empty())
1054 return;
1055
1056 {
1057 llvm::SmallString<4096> HashTableBlob;
1058 uint32_t Offset;
1059 {
1060 llvm::OnDiskChainedHashTableGenerator<GlobalVariableTableInfo> Generator;
1061 for (auto &GV : GlobalVariables)
1062 Generator.insert(Key: GV.first, Data&: GV.second);
1063
1064 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1065 // Make sure that no bucket is at offset 0
1066 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1067 endian: llvm::endianness::little);
1068 Offset = Generator.Emit(Out&: BlobStream);
1069 }
1070
1071 global_variable_block::GlobalVariableDataLayout GlobalVariableData(Stream);
1072 GlobalVariableData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1073 }
1074}
1075
1076namespace {
1077void emitBoundsSafetyInfo(raw_ostream &OS, const BoundsSafetyInfo &BSI) {
1078 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1079 uint8_t flags = 0;
1080 if (auto kind = BSI.getKind()) {
1081 assert(*kind <= BoundsSafetyInfo::BoundsSafetyKind::EndedBy);
1082 flags |= 0x01; // 1 bit
1083 flags |= (uint8_t)*kind << 1; // 3 bits
1084 }
1085 flags <<= 4;
1086 if (auto level = BSI.getLevel()) {
1087 assert(*level < (1u << 3));
1088 flags |= 0x01; // 1 bit
1089 flags |= (uint8_t)*level << 1; // 3 bits
1090 }
1091
1092 writer.write<uint8_t>(Val: flags);
1093 writer.write<uint16_t>(Val: BSI.ExternalBounds.size());
1094 writer.write(
1095 Val: ArrayRef<char>{BSI.ExternalBounds.data(), BSI.ExternalBounds.size()});
1096}
1097
1098unsigned getBoundsSafetyInfoSize(const BoundsSafetyInfo &BSI) {
1099 return 1 + sizeof(uint16_t) + BSI.ExternalBounds.size();
1100}
1101
1102unsigned getParamInfoSize(const ParamInfo &PI) {
1103 unsigned BSISize = 0;
1104 if (auto BSI = PI.BoundsSafety)
1105 BSISize = getBoundsSafetyInfoSize(BSI: *BSI);
1106 return getVariableInfoSize(VI: PI) + 1 + BSISize;
1107}
1108
1109void emitParamInfo(raw_ostream &OS, const ParamInfo &PI) {
1110 emitVariableInfo(OS, VI: PI);
1111
1112 uint8_t flags = 0;
1113 if (PI.BoundsSafety)
1114 flags |= 0x01;
1115 flags <<= 2;
1116 if (auto noescape = PI.isNoEscape()) {
1117 flags |= 0x01;
1118 if (*noescape)
1119 flags |= 0x02;
1120 }
1121 flags <<= 2;
1122 if (auto lifetimebound = PI.isLifetimebound()) {
1123 flags |= 0x01;
1124 if (*lifetimebound)
1125 flags |= 0x02;
1126 }
1127 flags <<= 3;
1128 if (auto RCC = PI.getRetainCountConvention())
1129 flags |= static_cast<uint8_t>(RCC.value()) + 1;
1130
1131 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1132 writer.write<uint8_t>(Val: flags);
1133 if (auto BSI = PI.BoundsSafety)
1134 emitBoundsSafetyInfo(OS, BSI: *BSI);
1135}
1136
1137/// Retrieve the serialized size of the given FunctionInfo, for use in on-disk
1138/// hash tables.
1139unsigned getFunctionInfoSize(const FunctionInfo &FI) {
1140 unsigned size = getCommonEntityInfoSize(CEI: FI) + 2 + sizeof(uint64_t);
1141 size += sizeof(uint16_t);
1142 for (const auto &P : FI.Params)
1143 size += getParamInfoSize(PI: P);
1144 size += sizeof(uint16_t) + FI.ResultType.size();
1145 size += sizeof(uint16_t) + FI.SwiftReturnOwnership.size();
1146 return size;
1147}
1148
1149/// Emit a serialized representation of the function information.
1150void emitFunctionInfo(raw_ostream &OS, const FunctionInfo &FI) {
1151 emitCommonEntityInfo(OS, CEI: FI);
1152
1153 uint8_t flags = 0;
1154 flags |= FI.NullabilityAudited;
1155 flags <<= 3;
1156 if (auto RCC = FI.getRetainCountConvention())
1157 flags |= static_cast<uint8_t>(RCC.value()) + 1;
1158
1159 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1160
1161 writer.write<uint8_t>(Val: flags);
1162 writer.write<uint8_t>(Val: FI.NumAdjustedNullable);
1163 writer.write<uint64_t>(Val: FI.NullabilityPayload);
1164
1165 writer.write<uint16_t>(Val: FI.Params.size());
1166 for (const auto &PI : FI.Params)
1167 emitParamInfo(OS, PI);
1168
1169 writer.write<uint16_t>(Val: FI.ResultType.size());
1170 writer.write(Val: ArrayRef<char>{FI.ResultType});
1171 writer.write<uint16_t>(Val: FI.SwiftReturnOwnership.size());
1172 writer.write(Val: ArrayRef<char>{FI.SwiftReturnOwnership});
1173}
1174
1175/// Used to serialize the on-disk global function table.
1176class GlobalFunctionTableInfo
1177 : public VersionedTableInfo<GlobalFunctionTableInfo, SingleDeclTableKey,
1178 GlobalFunctionInfo> {
1179public:
1180 unsigned getKeyLength(key_type_ref) {
1181 return sizeof(uint32_t) + sizeof(uint32_t);
1182 }
1183
1184 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
1185 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1186 writer.write<uint32_t>(Val: Key.parentContextID);
1187 writer.write<uint32_t>(Val: Key.nameID);
1188 }
1189
1190 hash_value_type ComputeHash(key_type_ref Key) {
1191 return static_cast<size_t>(Key.hashValue());
1192 }
1193
1194 unsigned getUnversionedInfoSize(const GlobalFunctionInfo &GFI) {
1195 return getFunctionInfoSize(FI: GFI);
1196 }
1197
1198 void emitUnversionedInfo(raw_ostream &OS, const GlobalFunctionInfo &GFI) {
1199 emitFunctionInfo(OS, FI: GFI);
1200 }
1201};
1202} // namespace
1203
1204void APINotesWriter::Implementation::writeGlobalFunctionBlock(
1205 llvm::BitstreamWriter &Stream) {
1206 llvm::BCBlockRAII Scope(Stream, GLOBAL_FUNCTION_BLOCK_ID, 3);
1207
1208 if (GlobalFunctions.empty())
1209 return;
1210
1211 {
1212 llvm::SmallString<4096> HashTableBlob;
1213 uint32_t Offset;
1214 {
1215 llvm::OnDiskChainedHashTableGenerator<GlobalFunctionTableInfo> Generator;
1216 for (auto &F : GlobalFunctions)
1217 Generator.insert(Key: F.first, Data&: F.second);
1218
1219 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1220 // Make sure that no bucket is at offset 0
1221 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1222 endian: llvm::endianness::little);
1223 Offset = Generator.Emit(Out&: BlobStream);
1224 }
1225
1226 global_function_block::GlobalFunctionDataLayout GlobalFunctionData(Stream);
1227 GlobalFunctionData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1228 }
1229}
1230
1231namespace {
1232/// Used to serialize the on-disk global enum constant.
1233class EnumConstantTableInfo
1234 : public VersionedTableInfo<EnumConstantTableInfo, unsigned,
1235 EnumConstantInfo> {
1236public:
1237 unsigned getKeyLength(key_type_ref) { return sizeof(uint32_t); }
1238
1239 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
1240 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1241 writer.write<uint32_t>(Val: Key);
1242 }
1243
1244 hash_value_type ComputeHash(key_type_ref Key) {
1245 return static_cast<size_t>(llvm::hash_value(value: Key));
1246 }
1247
1248 unsigned getUnversionedInfoSize(const EnumConstantInfo &ECI) {
1249 return getCommonEntityInfoSize(CEI: ECI);
1250 }
1251
1252 void emitUnversionedInfo(raw_ostream &OS, const EnumConstantInfo &ECI) {
1253 emitCommonEntityInfo(OS, CEI: ECI);
1254 }
1255};
1256} // namespace
1257
1258void APINotesWriter::Implementation::writeEnumConstantBlock(
1259 llvm::BitstreamWriter &Stream) {
1260 llvm::BCBlockRAII Scope(Stream, ENUM_CONSTANT_BLOCK_ID, 3);
1261
1262 if (EnumConstants.empty())
1263 return;
1264
1265 {
1266 llvm::SmallString<4096> HashTableBlob;
1267 uint32_t Offset;
1268 {
1269 llvm::OnDiskChainedHashTableGenerator<EnumConstantTableInfo> Generator;
1270 for (auto &EC : EnumConstants)
1271 Generator.insert(Key: EC.first, Data&: EC.second);
1272
1273 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1274 // Make sure that no bucket is at offset 0
1275 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1276 endian: llvm::endianness::little);
1277 Offset = Generator.Emit(Out&: BlobStream);
1278 }
1279
1280 enum_constant_block::EnumConstantDataLayout EnumConstantData(Stream);
1281 EnumConstantData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1282 }
1283}
1284
1285namespace {
1286template <typename Derived, typename UnversionedDataType>
1287class CommonTypeTableInfo
1288 : public VersionedTableInfo<Derived, SingleDeclTableKey,
1289 UnversionedDataType> {
1290public:
1291 using key_type_ref = typename CommonTypeTableInfo::key_type_ref;
1292 using hash_value_type = typename CommonTypeTableInfo::hash_value_type;
1293
1294 unsigned getKeyLength(key_type_ref) {
1295 return sizeof(uint32_t) + sizeof(IdentifierID);
1296 }
1297
1298 void EmitKey(raw_ostream &OS, key_type_ref Key, unsigned) {
1299 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1300 writer.write<uint32_t>(Key.parentContextID);
1301 writer.write<IdentifierID>(Key.nameID);
1302 }
1303
1304 hash_value_type ComputeHash(key_type_ref Key) {
1305 return static_cast<size_t>(Key.hashValue());
1306 }
1307
1308 unsigned getUnversionedInfoSize(const UnversionedDataType &UDT) {
1309 return getCommonTypeInfoSize(UDT);
1310 }
1311
1312 void emitUnversionedInfo(raw_ostream &OS, const UnversionedDataType &UDT) {
1313 emitCommonTypeInfo(OS, UDT);
1314 }
1315};
1316
1317/// Used to serialize the on-disk tag table.
1318class TagTableInfo : public CommonTypeTableInfo<TagTableInfo, TagInfo> {
1319public:
1320 unsigned getUnversionedInfoSize(const TagInfo &TI) {
1321 // clang-format off
1322 return 2 + (TI.SwiftImportAs ? TI.SwiftImportAs->size() : 0) +
1323 2 + (TI.SwiftRetainOp ? TI.SwiftRetainOp->size() : 0) +
1324 2 + (TI.SwiftReleaseOp ? TI.SwiftReleaseOp->size() : 0) +
1325 2 + (TI.SwiftDestroyOp ? TI.SwiftDestroyOp->size() : 0) +
1326 2 + (TI.SwiftDefaultOwnership ? TI.SwiftDefaultOwnership->size() : 0) +
1327 3 + getCommonTypeInfoSize(CTI: TI);
1328 // clang-format on
1329 }
1330
1331 void emitUnversionedInfo(raw_ostream &OS, const TagInfo &TI) {
1332 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1333
1334 uint8_t Flags = 0;
1335 if (auto extensibility = TI.EnumExtensibility) {
1336 Flags |= static_cast<uint8_t>(extensibility.value()) + 1;
1337 assert((Flags < (1 << 2)) && "must fit in two bits");
1338 }
1339
1340 Flags <<= 2;
1341 if (auto value = TI.isFlagEnum())
1342 Flags |= (value.value() << 1 | 1 << 0);
1343
1344 writer.write<uint8_t>(Val: Flags);
1345
1346 if (auto Copyable = TI.isSwiftCopyable())
1347 writer.write<uint8_t>(Val: *Copyable ? kSwiftConforms : kSwiftDoesNotConform);
1348 else
1349 writer.write<uint8_t>(Val: 0);
1350
1351 if (auto Escapable = TI.isSwiftEscapable())
1352 writer.write<uint8_t>(Val: *Escapable ? kSwiftConforms : kSwiftDoesNotConform);
1353 else
1354 writer.write<uint8_t>(Val: 0);
1355
1356 if (auto ImportAs = TI.SwiftImportAs) {
1357 writer.write<uint16_t>(Val: ImportAs->size() + 1);
1358 OS.write(Ptr: ImportAs->c_str(), Size: ImportAs->size());
1359 } else {
1360 writer.write<uint16_t>(Val: 0);
1361 }
1362 if (auto RetainOp = TI.SwiftRetainOp) {
1363 writer.write<uint16_t>(Val: RetainOp->size() + 1);
1364 OS.write(Ptr: RetainOp->c_str(), Size: RetainOp->size());
1365 } else {
1366 writer.write<uint16_t>(Val: 0);
1367 }
1368 if (auto ReleaseOp = TI.SwiftReleaseOp) {
1369 writer.write<uint16_t>(Val: ReleaseOp->size() + 1);
1370 OS.write(Ptr: ReleaseOp->c_str(), Size: ReleaseOp->size());
1371 } else {
1372 writer.write<uint16_t>(Val: 0);
1373 }
1374 if (auto DefaultOwnership = TI.SwiftDefaultOwnership) {
1375 writer.write<uint16_t>(Val: DefaultOwnership->size() + 1);
1376 OS.write(Ptr: DefaultOwnership->c_str(), Size: DefaultOwnership->size());
1377 } else {
1378 writer.write<uint16_t>(Val: 0);
1379 }
1380 if (auto DestroyOp = TI.SwiftDestroyOp) {
1381 writer.write<uint16_t>(Val: DestroyOp->size() + 1);
1382 OS.write(Ptr: DestroyOp->c_str(), Size: DestroyOp->size());
1383 } else {
1384 writer.write<uint16_t>(Val: 0);
1385 }
1386
1387 emitCommonTypeInfo(OS, CTI: TI);
1388 }
1389};
1390} // namespace
1391
1392void APINotesWriter::Implementation::writeTagBlock(
1393 llvm::BitstreamWriter &Stream) {
1394 llvm::BCBlockRAII Scope(Stream, TAG_BLOCK_ID, 3);
1395
1396 if (Tags.empty())
1397 return;
1398
1399 {
1400 llvm::SmallString<4096> HashTableBlob;
1401 uint32_t Offset;
1402 {
1403 llvm::OnDiskChainedHashTableGenerator<TagTableInfo> Generator;
1404 for (auto &T : Tags)
1405 Generator.insert(Key: T.first, Data&: T.second);
1406
1407 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1408 // Make sure that no bucket is at offset 0
1409 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1410 endian: llvm::endianness::little);
1411 Offset = Generator.Emit(Out&: BlobStream);
1412 }
1413
1414 tag_block::TagDataLayout TagData(Stream);
1415 TagData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1416 }
1417}
1418
1419namespace {
1420/// Used to serialize the on-disk typedef table.
1421class TypedefTableInfo
1422 : public CommonTypeTableInfo<TypedefTableInfo, TypedefInfo> {
1423public:
1424 unsigned getUnversionedInfoSize(const TypedefInfo &TI) {
1425 return 1 + getCommonTypeInfoSize(CTI: TI);
1426 }
1427
1428 void emitUnversionedInfo(raw_ostream &OS, const TypedefInfo &TI) {
1429 llvm::support::endian::Writer writer(OS, llvm::endianness::little);
1430
1431 uint8_t Flags = 0;
1432 if (auto swiftWrapper = TI.SwiftWrapper)
1433 Flags |= static_cast<uint8_t>(*swiftWrapper) + 1;
1434
1435 writer.write<uint8_t>(Val: Flags);
1436
1437 emitCommonTypeInfo(OS, CTI: TI);
1438 }
1439};
1440} // namespace
1441
1442void APINotesWriter::Implementation::writeTypedefBlock(
1443 llvm::BitstreamWriter &Stream) {
1444 llvm::BCBlockRAII Scope(Stream, TYPEDEF_BLOCK_ID, 3);
1445
1446 if (Typedefs.empty())
1447 return;
1448
1449 {
1450 llvm::SmallString<4096> HashTableBlob;
1451 uint32_t Offset;
1452 {
1453 llvm::OnDiskChainedHashTableGenerator<TypedefTableInfo> Generator;
1454 for (auto &T : Typedefs)
1455 Generator.insert(Key: T.first, Data&: T.second);
1456
1457 llvm::raw_svector_ostream BlobStream(HashTableBlob);
1458 // Make sure that no bucket is at offset 0
1459 llvm::support::endian::write<uint32_t>(os&: BlobStream, value: 0,
1460 endian: llvm::endianness::little);
1461 Offset = Generator.Emit(Out&: BlobStream);
1462 }
1463
1464 typedef_block::TypedefDataLayout TypedefData(Stream);
1465 TypedefData.emit(buffer&: Scratch, data&: Offset, data&: HashTableBlob);
1466 }
1467}
1468
1469// APINotesWriter
1470
1471APINotesWriter::APINotesWriter(llvm::StringRef ModuleName, const FileEntry *SF)
1472 : Implementation(new class Implementation(ModuleName, SF)) {}
1473
1474APINotesWriter::~APINotesWriter() = default;
1475
1476void APINotesWriter::writeToStream(llvm::raw_ostream &OS) {
1477 Implementation->writeToStream(OS);
1478}
1479
1480ContextID APINotesWriter::addContext(std::optional<ContextID> ParentCtxID,
1481 llvm::StringRef Name, ContextKind Kind,
1482 const ContextInfo &Info,
1483 llvm::VersionTuple SwiftVersion) {
1484 IdentifierID NameID = Implementation->getIdentifier(Identifier: Name);
1485
1486 uint32_t RawParentCtxID = ParentCtxID ? ParentCtxID->Value : -1;
1487 ContextTableKey Key(RawParentCtxID, static_cast<uint8_t>(Kind), NameID);
1488 auto Known = Implementation->Contexts.find(Val: Key);
1489 if (Known == Implementation->Contexts.end()) {
1490 unsigned NextID = Implementation->Contexts.size() + 1;
1491
1492 Implementation::VersionedSmallVector<ContextInfo> EmptyVersionedInfo;
1493 Known = Implementation->Contexts
1494 .insert(KV: std::make_pair(
1495 x&: Key, y: std::make_pair(x&: NextID, y&: EmptyVersionedInfo)))
1496 .first;
1497
1498 Implementation->ContextNames[NextID] = NameID;
1499 Implementation->ParentContexts[NextID] = RawParentCtxID;
1500 Implementation->ContextKinds[NextID] = static_cast<uint8_t>(Kind);
1501 }
1502
1503 // Add this version information.
1504 auto &VersionedVec = Known->second.second;
1505 bool Found = false;
1506 for (auto &Versioned : VersionedVec) {
1507 if (Versioned.first == SwiftVersion) {
1508 Versioned.second |= Info;
1509 Found = true;
1510 break;
1511 }
1512 }
1513
1514 if (!Found)
1515 VersionedVec.push_back(Elt: {SwiftVersion, Info});
1516
1517 return ContextID(Known->second.first);
1518}
1519
1520void APINotesWriter::addObjCProperty(ContextID CtxID, StringRef Name,
1521 bool IsInstanceProperty,
1522 const ObjCPropertyInfo &Info,
1523 VersionTuple SwiftVersion) {
1524 IdentifierID NameID = Implementation->getIdentifier(Identifier: Name);
1525 Implementation
1526 ->ObjCProperties[std::make_tuple(args&: CtxID.Value, args&: NameID, args&: IsInstanceProperty)]
1527 .push_back(Elt: {SwiftVersion, Info});
1528}
1529
1530void APINotesWriter::addObjCMethod(ContextID CtxID, ObjCSelectorRef Selector,
1531 bool IsInstanceMethod,
1532 const ObjCMethodInfo &Info,
1533 VersionTuple SwiftVersion) {
1534 SelectorID SelID = Implementation->getSelector(SelectorRef: Selector);
1535 auto Key = std::tuple<unsigned, unsigned, char>{CtxID.Value, SelID,
1536 IsInstanceMethod};
1537 Implementation->ObjCMethods[Key].push_back(Elt: {SwiftVersion, Info});
1538
1539 // If this method is a designated initializer, update the class to note that
1540 // it has designated initializers.
1541 if (Info.DesignatedInit) {
1542 assert(Implementation->ParentContexts.contains(CtxID.Value));
1543 uint32_t ParentCtxID = Implementation->ParentContexts[CtxID.Value];
1544 ContextTableKey CtxKey(ParentCtxID,
1545 Implementation->ContextKinds[CtxID.Value],
1546 Implementation->ContextNames[CtxID.Value]);
1547 assert(Implementation->Contexts.contains(CtxKey));
1548 auto &VersionedVec = Implementation->Contexts[CtxKey].second;
1549 bool Found = false;
1550 for (auto &Versioned : VersionedVec) {
1551 if (Versioned.first == SwiftVersion) {
1552 Versioned.second.setHasDesignatedInits(true);
1553 Found = true;
1554 break;
1555 }
1556 }
1557
1558 if (!Found) {
1559 VersionedVec.push_back(Elt: {SwiftVersion, ContextInfo()});
1560 VersionedVec.back().second.setHasDesignatedInits(true);
1561 }
1562 }
1563}
1564
1565void APINotesWriter::addCXXMethod(ContextID CtxID, llvm::StringRef Name,
1566 const CXXMethodInfo &Info,
1567 VersionTuple SwiftVersion) {
1568 IdentifierID NameID = Implementation->getIdentifier(Identifier: Name);
1569 SingleDeclTableKey Key(CtxID.Value, NameID);
1570 Implementation->CXXMethods[Key].push_back(Elt: {SwiftVersion, Info});
1571}
1572
1573void APINotesWriter::addField(ContextID CtxID, llvm::StringRef Name,
1574 const FieldInfo &Info,
1575 VersionTuple SwiftVersion) {
1576 IdentifierID NameID = Implementation->getIdentifier(Identifier: Name);
1577 SingleDeclTableKey Key(CtxID.Value, NameID);
1578 Implementation->Fields[Key].push_back(Elt: {SwiftVersion, Info});
1579}
1580
1581void APINotesWriter::addGlobalVariable(std::optional<Context> Ctx,
1582 llvm::StringRef Name,
1583 const GlobalVariableInfo &Info,
1584 VersionTuple SwiftVersion) {
1585 IdentifierID VariableID = Implementation->getIdentifier(Identifier: Name);
1586 SingleDeclTableKey Key(Ctx, VariableID);
1587 Implementation->GlobalVariables[Key].push_back(Elt: {SwiftVersion, Info});
1588}
1589
1590void APINotesWriter::addGlobalFunction(std::optional<Context> Ctx,
1591 llvm::StringRef Name,
1592 const GlobalFunctionInfo &Info,
1593 VersionTuple SwiftVersion) {
1594 IdentifierID NameID = Implementation->getIdentifier(Identifier: Name);
1595 SingleDeclTableKey Key(Ctx, NameID);
1596 Implementation->GlobalFunctions[Key].push_back(Elt: {SwiftVersion, Info});
1597}
1598
1599void APINotesWriter::addEnumConstant(llvm::StringRef Name,
1600 const EnumConstantInfo &Info,
1601 VersionTuple SwiftVersion) {
1602 IdentifierID EnumConstantID = Implementation->getIdentifier(Identifier: Name);
1603 Implementation->EnumConstants[EnumConstantID].push_back(Elt: {SwiftVersion, Info});
1604}
1605
1606void APINotesWriter::addTag(std::optional<Context> Ctx, llvm::StringRef Name,
1607 const TagInfo &Info, VersionTuple SwiftVersion) {
1608 IdentifierID TagID = Implementation->getIdentifier(Identifier: Name);
1609 SingleDeclTableKey Key(Ctx, TagID);
1610 Implementation->Tags[Key].push_back(Elt: {SwiftVersion, Info});
1611}
1612
1613void APINotesWriter::addTypedef(std::optional<Context> Ctx,
1614 llvm::StringRef Name, const TypedefInfo &Info,
1615 VersionTuple SwiftVersion) {
1616 IdentifierID TypedefID = Implementation->getIdentifier(Identifier: Name);
1617 SingleDeclTableKey Key(Ctx, TypedefID);
1618 Implementation->Typedefs[Key].push_back(Elt: {SwiftVersion, Info});
1619}
1620} // namespace api_notes
1621} // namespace clang
1622