mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
c857a480e1
This is going to be used for "always emit into client" functions, such as default argument generators and stored property initializers. - In dead function elimination, these functions behave identically to public functions, serving as "anchors" for the mark-and-sweep analysis. - There is no external variant of this linkage, because external declarations can use HiddenExternal linkage -- the definition should always be emitted by another translation unit in the same Swift module. - When deserialized, they receive shared linkage, because we want the linker to coalesce multiple copies of the same deserialized definition if it was deserialized from multiple translation units in the same Swift module. - When IRGen emits a definition with this linkage, it receives the same LLVM-level linkage as a hidden definition, ensuring it does not have a public entry point.
1665 lines
48 KiB
C++
1665 lines
48 KiB
C++
//===--- ModuleFormat.h - The internals of serialized modules ---*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// \brief Contains various constants and helper types to deal with serialized
|
|
/// modules.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_SERIALIZATION_MODULEFORMAT_H
|
|
#define SWIFT_SERIALIZATION_MODULEFORMAT_H
|
|
|
|
#include "swift/AST/Decl.h"
|
|
#include "swift/AST/Types.h"
|
|
#include "llvm/Bitcode/RecordLayout.h"
|
|
#include "llvm/Bitcode/BitCodes.h"
|
|
#include "llvm/ADT/PointerEmbeddedInt.h"
|
|
|
|
namespace swift {
|
|
namespace serialization {
|
|
|
|
using llvm::PointerEmbeddedInt;
|
|
using llvm::BCArray;
|
|
using llvm::BCBlob;
|
|
using llvm::BCFixed;
|
|
using llvm::BCGenericRecordLayout;
|
|
using llvm::BCRecordLayout;
|
|
using llvm::BCVBR;
|
|
|
|
/// Magic number for serialized module files.
|
|
const unsigned char MODULE_SIGNATURE[] = { 0xE2, 0x9C, 0xA8, 0x0E };
|
|
|
|
/// Magic number for serialized documentation files.
|
|
const unsigned char MODULE_DOC_SIGNATURE[] = { 0xE2, 0x9C, 0xA8, 0x07 };
|
|
|
|
/// Serialized module format major version number.
|
|
///
|
|
/// Always 0 for Swift 1.x - 4.x.
|
|
const uint16_t VERSION_MAJOR = 0;
|
|
|
|
/// Serialized module format minor version number.
|
|
///
|
|
/// When the format changes IN ANY WAY, this number should be incremented.
|
|
/// To ensure that two separate changes don't silently get merged into one
|
|
/// in source control, you should also update the comment to briefly
|
|
/// describe what change you made. The content of this comment isn't important;
|
|
/// it just ensures a conflict if two people change the module format.
|
|
const uint16_t VERSION_MINOR = 393; // SILLinkage::PublicNonABI
|
|
|
|
using DeclIDField = BCFixed<31>;
|
|
|
|
// TypeID must be the same as DeclID because it is stored in the same way.
|
|
using TypeID = DeclID;
|
|
using TypeIDField = DeclIDField;
|
|
|
|
using TypeIDWithBitField = BCFixed<32>;
|
|
|
|
// IdentifierID must be the same as DeclID because it is stored in the same way.
|
|
using IdentifierID = DeclID;
|
|
using IdentifierIDField = DeclIDField;
|
|
|
|
// DeclContextID must be the same as DeclID because it is stored in the same way.
|
|
using DeclContextID = DeclID;
|
|
using DeclContextIDField = DeclIDField;
|
|
|
|
// NormalConformanceID must be the same as DeclID because it is stored
|
|
// in the same way.
|
|
using NormalConformanceID = DeclID;
|
|
using NormalConformanceIDField = DeclIDField;
|
|
|
|
// GenericSignatureID must be the same as DeclID because it is stored in the
|
|
// same way.
|
|
using GenericSignatureID = DeclID;
|
|
using GenericSignatureIDField = DeclIDField;
|
|
|
|
// GenericEnvironmentID must be the same as DeclID because it is stored in the
|
|
// same way.
|
|
using GenericEnvironmentID = DeclID;
|
|
using GenericEnvironmentIDField = DeclIDField;
|
|
|
|
// ModuleID must be the same as IdentifierID because it is stored the same way.
|
|
using ModuleID = IdentifierID;
|
|
using ModuleIDField = IdentifierIDField;
|
|
|
|
// SILLayoutID must be the same as DeclID because it is stored in the same way.
|
|
using SILLayoutID = DeclID;
|
|
using SILLayoutIDField = DeclIDField;
|
|
|
|
using BitOffset = PointerEmbeddedInt<unsigned, 31>;
|
|
using BitOffsetField = BCFixed<31>;
|
|
|
|
// CharOffset must be the same as BitOffset because it is stored in the
|
|
// same way.
|
|
using CharOffset = BitOffset;
|
|
using CharOffsetField = BitOffsetField;
|
|
|
|
using FileSizeField = BCVBR<16>;
|
|
using FileModTimeField = BCVBR<16>;
|
|
|
|
enum class StorageKind : uint8_t {
|
|
Stored, StoredWithTrivialAccessors, StoredWithObservers,
|
|
InheritedWithObservers,
|
|
Computed, ComputedWithMutableAddress,
|
|
Addressed, AddressedWithTrivialAccessors, AddressedWithObservers,
|
|
};
|
|
using StorageKindField = BCFixed<4>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class StaticSpellingKind : uint8_t {
|
|
None = 0,
|
|
KeywordStatic,
|
|
KeywordClass,
|
|
};
|
|
using StaticSpellingKindField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class FunctionTypeRepresentation : uint8_t {
|
|
Swift = 0,
|
|
Block,
|
|
Thin,
|
|
CFunctionPointer,
|
|
};
|
|
using FunctionTypeRepresentationField = BCFixed<4>;
|
|
|
|
enum class ForeignErrorConventionKind : uint8_t {
|
|
ZeroResult,
|
|
NonZeroResult,
|
|
ZeroPreservedResult,
|
|
NilResult,
|
|
NonNilError,
|
|
};
|
|
|
|
using ForeignErrorConventionKindField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class SILFunctionTypeRepresentation : uint8_t {
|
|
Thick = 0,
|
|
Block,
|
|
Thin,
|
|
CFunctionPointer,
|
|
|
|
FirstSIL = 8,
|
|
Method = FirstSIL,
|
|
ObjCMethod,
|
|
WitnessMethod,
|
|
Closure,
|
|
};
|
|
using SILFunctionTypeRepresentationField = BCFixed<4>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class SILCoroutineKind : uint8_t {
|
|
None = 0,
|
|
YieldOnce = 1,
|
|
YieldMany = 2,
|
|
};
|
|
using SILCoroutineKindField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum OperatorKind : uint8_t {
|
|
Infix = 0,
|
|
Prefix,
|
|
Postfix,
|
|
PrecedenceGroup, // only for cross references
|
|
};
|
|
// This is currently required to have the same width as AccessorKindField.
|
|
using OperatorKindField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum AccessorKind : uint8_t {
|
|
Getter = 0,
|
|
Setter,
|
|
WillSet,
|
|
DidSet,
|
|
MaterializeForSet,
|
|
Addressor,
|
|
MutableAddressor,
|
|
};
|
|
using AccessorKindField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum CtorInitializerKind : uint8_t {
|
|
Designated = 0,
|
|
Convenience = 1,
|
|
Factory = 2,
|
|
ConvenienceFactory = 3,
|
|
};
|
|
using CtorInitializerKindField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class VarDeclSpecifier : uint8_t {
|
|
Let = 0,
|
|
Var,
|
|
InOut,
|
|
Shared,
|
|
};
|
|
using VarDeclSpecifierField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class ParameterConvention : uint8_t {
|
|
Indirect_In,
|
|
Indirect_Inout,
|
|
Indirect_InoutAliasable,
|
|
Direct_Owned,
|
|
Direct_Unowned,
|
|
Direct_Guaranteed,
|
|
Indirect_In_Guaranteed,
|
|
Indirect_In_Constant,
|
|
};
|
|
using ParameterConventionField = BCFixed<4>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class ResultConvention : uint8_t {
|
|
Indirect,
|
|
Owned,
|
|
Unowned,
|
|
UnownedInnerPointer,
|
|
Autoreleased,
|
|
};
|
|
using ResultConventionField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum MetatypeRepresentation : uint8_t {
|
|
MR_None, MR_Thin, MR_Thick, MR_ObjC
|
|
};
|
|
using MetatypeRepresentationField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class AddressorKind : uint8_t {
|
|
NotAddressor, Unsafe, Owning, NativeOwning, NativePinning
|
|
};
|
|
using AddressorKindField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class SelfAccessKind : uint8_t {
|
|
NonMutating = 0,
|
|
Mutating,
|
|
__Consuming,
|
|
};
|
|
using SelfAccessKindField = BCFixed<2>;
|
|
|
|
/// Translates an operator DeclKind to a Serialization fixity, whose values are
|
|
/// guaranteed to be stable.
|
|
static inline OperatorKind getStableFixity(DeclKind kind) {
|
|
switch (kind) {
|
|
case DeclKind::PrefixOperator:
|
|
return Prefix;
|
|
case DeclKind::PostfixOperator:
|
|
return Postfix;
|
|
case DeclKind::InfixOperator:
|
|
return Infix;
|
|
default:
|
|
llvm_unreachable("unknown operator fixity");
|
|
}
|
|
}
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum GenericRequirementKind : uint8_t {
|
|
Conformance = 0,
|
|
SameType = 1,
|
|
Superclass = 2,
|
|
Layout = 3,
|
|
};
|
|
using GenericRequirementKindField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum LayoutRequirementKind : uint8_t {
|
|
UnknownLayout = 0,
|
|
TrivialOfExactSize = 1,
|
|
TrivialOfAtMostSize = 2,
|
|
Trivial = 3,
|
|
RefCountedObject = 4,
|
|
NativeRefCountedObject = 5,
|
|
Class = 6,
|
|
NativeClass = 7
|
|
};
|
|
using LayoutRequirementKindField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum Associativity : uint8_t {
|
|
NonAssociative = 0,
|
|
LeftAssociative,
|
|
RightAssociative
|
|
};
|
|
using AssociativityField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum Ownership : uint8_t {
|
|
Strong = 0,
|
|
Weak,
|
|
Unowned,
|
|
Unmanaged,
|
|
};
|
|
using OwnershipField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class DefaultArgumentKind : uint8_t {
|
|
None = 0,
|
|
Normal,
|
|
File,
|
|
Line,
|
|
Column,
|
|
Function,
|
|
Inherited,
|
|
DSOHandle,
|
|
NilLiteral,
|
|
EmptyArray,
|
|
EmptyDictionary,
|
|
};
|
|
using DefaultArgumentField = BCFixed<4>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum LibraryKind : uint8_t {
|
|
Library = 0,
|
|
Framework
|
|
};
|
|
using LibraryKindField = BCFixed<1>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class AccessLevel : uint8_t {
|
|
Private = 0,
|
|
FilePrivate,
|
|
Internal,
|
|
Public,
|
|
Open,
|
|
};
|
|
using AccessLevelField = BCFixed<3>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class OptionalTypeKind : uint8_t {
|
|
None,
|
|
Optional,
|
|
ImplicitlyUnwrappedOptional
|
|
};
|
|
using OptionalTypeKindField = BCFixed<2>;
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class DeclNameKind: uint8_t {
|
|
Normal,
|
|
Subscript,
|
|
Destructor
|
|
};
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum SpecialIdentifierID : uint8_t {
|
|
/// Special IdentifierID value for the Builtin module.
|
|
BUILTIN_MODULE_ID = 0,
|
|
/// Special IdentifierID value for the current module.
|
|
CURRENT_MODULE_ID,
|
|
/// Special value for the module for imported Objective-C headers.
|
|
OBJC_HEADER_MODULE_ID,
|
|
/// Special value for the special subscript name
|
|
SUBSCRIPT_ID,
|
|
/// Special value for the special destructor name
|
|
DESTRUCTOR_ID,
|
|
|
|
/// The number of special Identifier IDs. This value should never be encoded;
|
|
/// it should only be used to count the number of names above. As such, it
|
|
/// is correct and necessary to add new values above this one.
|
|
NUM_SPECIAL_IDS
|
|
};
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class EnumElementRawValueKind : uint8_t {
|
|
/// No raw value serialized.
|
|
None = 0,
|
|
/// Integer literal.
|
|
IntegerLiteral,
|
|
/// TODO: Float, string, char, etc.
|
|
};
|
|
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum class ResilienceExpansion : uint8_t {
|
|
Minimal = 0,
|
|
Maximal,
|
|
};
|
|
|
|
using EnumElementRawValueKindField = BCFixed<4>;
|
|
|
|
/// The various types of blocks that can occur within a serialized Swift
|
|
/// module.
|
|
///
|
|
/// These IDs must \em not be renumbered or reordered without incrementing
|
|
/// VERSION_MAJOR.
|
|
enum BlockID {
|
|
/// The module block, which contains all of the other blocks (and in theory
|
|
/// allows a single file to contain multiple modules).
|
|
MODULE_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
|
|
|
|
/// The control block, which contains all of the information that needs to
|
|
/// be validated prior to committing to loading the serialized module.
|
|
///
|
|
/// \sa control_block
|
|
CONTROL_BLOCK_ID,
|
|
|
|
/// The input block, which contains all the files this module depends on.
|
|
///
|
|
/// \sa input_block
|
|
INPUT_BLOCK_ID,
|
|
|
|
/// The "decls-and-types" block, which contains all of the declarations that
|
|
/// come from this module.
|
|
///
|
|
/// Types are also stored here, so that types that just wrap a Decl don't need
|
|
/// a separate entry in the file.
|
|
///
|
|
/// \sa decls_block
|
|
DECLS_AND_TYPES_BLOCK_ID,
|
|
|
|
/// The identifier block, which contains all of the strings used in
|
|
/// identifiers in the module.
|
|
///
|
|
/// Unlike other blocks in the file, all data within this block is completely
|
|
/// opaque. Offsets into this block should point directly into the blob at a
|
|
/// null-terminated UTF-8 string.
|
|
IDENTIFIER_DATA_BLOCK_ID,
|
|
|
|
/// The index block, which contains cross-referencing information for the
|
|
/// module.
|
|
///
|
|
/// \sa index_block
|
|
INDEX_BLOCK_ID,
|
|
|
|
/// The block for SIL functions.
|
|
///
|
|
/// \sa sil_block
|
|
SIL_BLOCK_ID,
|
|
|
|
/// The index block for SIL functions.
|
|
///
|
|
/// \sa sil_index_block
|
|
SIL_INDEX_BLOCK_ID,
|
|
|
|
/// A sub-block of the control block that contains configuration options
|
|
/// needed to successfully load this module.
|
|
///
|
|
/// \sa options_block
|
|
OPTIONS_BLOCK_ID,
|
|
|
|
/// The module documentation container block, which contains all other
|
|
/// documentation blocks.
|
|
MODULE_DOC_BLOCK_ID = 96,
|
|
|
|
/// The comment block, which contains documentation comments.
|
|
///
|
|
/// \sa comment_block
|
|
COMMENT_BLOCK_ID,
|
|
|
|
/// The declaration member-tables index block, a sub-blocb of the index block.
|
|
///
|
|
/// \sa decl_member_tables_block
|
|
DECL_MEMBER_TABLES_BLOCK_ID
|
|
};
|
|
|
|
/// The record types within the control block.
|
|
///
|
|
/// \sa CONTROL_BLOCK_ID
|
|
namespace control_block {
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum {
|
|
METADATA = 1,
|
|
MODULE_NAME,
|
|
TARGET
|
|
};
|
|
|
|
using MetadataLayout = BCRecordLayout<
|
|
METADATA, // ID
|
|
BCFixed<16>, // Module format major version
|
|
BCFixed<16>, // Module format minor version
|
|
BCVBR<8>, // length of "short version string" in the blob
|
|
BCVBR<8>, // length of "short compatibility version string" in the blob
|
|
BCBlob // misc. version information
|
|
>;
|
|
|
|
using ModuleNameLayout = BCRecordLayout<
|
|
MODULE_NAME,
|
|
BCBlob
|
|
>;
|
|
|
|
using TargetLayout = BCRecordLayout<
|
|
TARGET,
|
|
BCBlob // LLVM triple
|
|
>;
|
|
}
|
|
|
|
/// The record types within the options block (a sub-block of the control
|
|
/// block).
|
|
///
|
|
/// \sa OPTIONS_BLOCK_ID
|
|
namespace options_block {
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum {
|
|
SDK_PATH = 1,
|
|
XCC,
|
|
IS_SIB,
|
|
IS_TESTABLE,
|
|
RESILIENCE_STRATEGY
|
|
};
|
|
|
|
using SDKPathLayout = BCRecordLayout<
|
|
SDK_PATH,
|
|
BCBlob // path
|
|
>;
|
|
|
|
using XCCLayout = BCRecordLayout<
|
|
XCC,
|
|
BCBlob // -Xcc flag, as string
|
|
>;
|
|
|
|
using IsSIBLayout = BCRecordLayout<
|
|
IS_SIB,
|
|
BCFixed<1> // Is this an intermediate file?
|
|
>;
|
|
|
|
using IsTestableLayout = BCRecordLayout<
|
|
IS_TESTABLE
|
|
>;
|
|
|
|
using ResilienceStrategyLayout = BCRecordLayout<
|
|
RESILIENCE_STRATEGY,
|
|
BCFixed<2>
|
|
>;
|
|
}
|
|
|
|
/// The record types within the input block.
|
|
///
|
|
/// \sa INPUT_BLOCK_ID
|
|
namespace input_block {
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum {
|
|
IMPORTED_MODULE = 1,
|
|
LINK_LIBRARY,
|
|
IMPORTED_HEADER,
|
|
IMPORTED_HEADER_CONTENTS,
|
|
MODULE_FLAGS,
|
|
SEARCH_PATH
|
|
};
|
|
|
|
using ImportedModuleLayout = BCRecordLayout<
|
|
IMPORTED_MODULE,
|
|
BCFixed<1>, // exported?
|
|
BCFixed<1>, // scoped?
|
|
BCBlob // module name, with submodule path pieces separated by \0s.
|
|
// If the 'scoped' flag is set, the final path piece is an access
|
|
// path within the module.
|
|
>;
|
|
|
|
using LinkLibraryLayout = BCRecordLayout<
|
|
LINK_LIBRARY,
|
|
LibraryKindField, // kind
|
|
BCFixed<1>, // forced?
|
|
BCBlob // library name
|
|
>;
|
|
|
|
using ImportedHeaderLayout = BCRecordLayout<
|
|
IMPORTED_HEADER,
|
|
BCFixed<1>, // exported?
|
|
FileSizeField, // file size (for validation)
|
|
FileModTimeField, // file mtime (for validation)
|
|
BCBlob // file path
|
|
>;
|
|
|
|
using ImportedHeaderContentsLayout = BCRecordLayout<
|
|
IMPORTED_HEADER_CONTENTS,
|
|
BCBlob
|
|
>;
|
|
|
|
using ModuleFlagsLayout = BCRecordLayout<
|
|
MODULE_FLAGS,
|
|
BCFixed<1> // has underlying module? [[UNUSED]]
|
|
>;
|
|
|
|
using SearchPathLayout = BCRecordLayout<
|
|
SEARCH_PATH,
|
|
BCFixed<1>, // framework?
|
|
BCFixed<1>, // system?
|
|
BCBlob // path
|
|
>;
|
|
}
|
|
|
|
/// The record types within the "decls-and-types" block.
|
|
///
|
|
/// \sa DECLS_AND_TYPES_BLOCK_ID
|
|
namespace decls_block {
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum RecordKind : uint8_t {
|
|
#define RECORD(Id) Id,
|
|
#define RECORD_VAL(Id, Value) Id = Value,
|
|
#include "swift/Serialization/DeclTypeRecordNodes.def"
|
|
};
|
|
|
|
using NameAliasTypeLayout = BCRecordLayout<
|
|
NAME_ALIAS_TYPE,
|
|
DeclIDField, // typealias decl
|
|
TypeIDField // canonical type (a fallback)
|
|
>;
|
|
|
|
using GenericTypeParamTypeLayout = BCRecordLayout<
|
|
GENERIC_TYPE_PARAM_TYPE,
|
|
DeclIDField, // generic type parameter decl or depth
|
|
BCVBR<4> // index + 1, or zero if we have a generic type parameter decl
|
|
>;
|
|
|
|
using DependentMemberTypeLayout = BCRecordLayout<
|
|
DEPENDENT_MEMBER_TYPE,
|
|
TypeIDField, // base type
|
|
DeclIDField // associated type decl
|
|
>;
|
|
using NominalTypeLayout = BCRecordLayout<
|
|
NOMINAL_TYPE,
|
|
DeclIDField, // decl
|
|
TypeIDField // parent
|
|
>;
|
|
|
|
using ParenTypeLayout = BCRecordLayout<
|
|
PAREN_TYPE,
|
|
TypeIDField, // inner type
|
|
BCFixed<1>, // vararg?
|
|
BCFixed<1>, // autoclosure?
|
|
BCFixed<1>, // escaping?
|
|
BCFixed<1>, // inout?
|
|
BCFixed<1> // shared?
|
|
>;
|
|
|
|
using TupleTypeLayout = BCRecordLayout<
|
|
TUPLE_TYPE
|
|
>;
|
|
|
|
using TupleTypeEltLayout = BCRecordLayout<
|
|
TUPLE_TYPE_ELT,
|
|
IdentifierIDField, // name
|
|
TypeIDField, // type
|
|
BCFixed<1>, // vararg?
|
|
BCFixed<1>, // autoclosure?
|
|
BCFixed<1>, // escaping?
|
|
BCFixed<1>, // inout?
|
|
BCFixed<1> // shared?
|
|
>;
|
|
|
|
using FunctionTypeLayout = BCRecordLayout<
|
|
FUNCTION_TYPE,
|
|
TypeIDField, // input
|
|
TypeIDField, // output
|
|
FunctionTypeRepresentationField, // representation
|
|
BCFixed<1>, // auto-closure?
|
|
BCFixed<1>, // noescape?
|
|
BCFixed<1> // throws?
|
|
>;
|
|
|
|
using MetatypeTypeLayout = BCRecordLayout<
|
|
METATYPE_TYPE,
|
|
TypeIDField, // instance type
|
|
MetatypeRepresentationField // representation
|
|
>;
|
|
|
|
using ExistentialMetatypeTypeLayout = BCRecordLayout<
|
|
EXISTENTIAL_METATYPE_TYPE,
|
|
TypeIDField, // instance type
|
|
MetatypeRepresentationField // representation
|
|
>;
|
|
|
|
using InOutTypeLayout = BCRecordLayout<
|
|
INOUT_TYPE,
|
|
TypeIDField // object type
|
|
>;
|
|
|
|
using ArchetypeTypeLayout = BCRecordLayout<
|
|
ARCHETYPE_TYPE,
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField // interface type
|
|
>;
|
|
|
|
using OpenedExistentialTypeLayout = BCRecordLayout<
|
|
OPENED_EXISTENTIAL_TYPE,
|
|
TypeIDField // the existential type
|
|
>;
|
|
|
|
using DynamicSelfTypeLayout = BCRecordLayout<
|
|
DYNAMIC_SELF_TYPE,
|
|
TypeIDField // self type
|
|
>;
|
|
|
|
using ProtocolCompositionTypeLayout = BCRecordLayout<
|
|
PROTOCOL_COMPOSITION_TYPE,
|
|
BCFixed<1>, // has AnyObject constraint
|
|
BCArray<TypeIDField> // protocols
|
|
>;
|
|
|
|
using BoundGenericTypeLayout = BCRecordLayout<
|
|
BOUND_GENERIC_TYPE,
|
|
DeclIDField, // generic decl
|
|
TypeIDField, // parent
|
|
BCArray<TypeIDField> // generic arguments
|
|
>;
|
|
|
|
using BoundGenericSubstitutionLayout = BCRecordLayout<
|
|
BOUND_GENERIC_SUBSTITUTION,
|
|
TypeIDField, // replacement
|
|
BCVBR<5>
|
|
// Trailed by protocol conformance info (if any)
|
|
>;
|
|
|
|
using GenericFunctionTypeLayout = BCRecordLayout<
|
|
GENERIC_FUNCTION_TYPE,
|
|
TypeIDField, // input
|
|
TypeIDField, // output
|
|
FunctionTypeRepresentationField, // representation
|
|
BCFixed<1>, // throws?
|
|
GenericSignatureIDField // generic signture
|
|
>;
|
|
|
|
using SILFunctionTypeLayout = BCRecordLayout<
|
|
SIL_FUNCTION_TYPE,
|
|
SILCoroutineKindField, // coroutine kind
|
|
ParameterConventionField, // callee convention
|
|
SILFunctionTypeRepresentationField, // representation
|
|
BCFixed<1>, // pseudogeneric?
|
|
BCFixed<1>, // noescape?
|
|
BCFixed<1>, // error result?
|
|
BCFixed<30>, // number of parameters
|
|
BCFixed<30>, // number of yields
|
|
BCFixed<30>, // number of results
|
|
GenericSignatureIDField, // generic signature
|
|
BCArray<TypeIDField> // parameter types/conventions, alternating
|
|
// followed by result types/conventions, alternating
|
|
// followed by error result type/convention
|
|
// Optionally a protocol conformance (for witness_methods)
|
|
>;
|
|
|
|
using SILBlockStorageTypeLayout = BCRecordLayout<
|
|
SIL_BLOCK_STORAGE_TYPE,
|
|
TypeIDField // capture type
|
|
>;
|
|
|
|
using SILLayoutLayout = BCRecordLayout<
|
|
SIL_LAYOUT,
|
|
GenericSignatureIDField, // generic signature
|
|
BCFixed<31>, // number of fields
|
|
BCArray<TypeIDWithBitField> // field types with mutability
|
|
>;
|
|
|
|
using SILBoxTypeLayout = BCRecordLayout<
|
|
SIL_BOX_TYPE,
|
|
SILLayoutIDField // layout
|
|
// trailing substitutions
|
|
>;
|
|
|
|
template <unsigned Code>
|
|
using SyntaxSugarTypeLayout = BCRecordLayout<
|
|
Code,
|
|
TypeIDField // element type
|
|
>;
|
|
|
|
using ArraySliceTypeLayout = SyntaxSugarTypeLayout<ARRAY_SLICE_TYPE>;
|
|
using OptionalTypeLayout = SyntaxSugarTypeLayout<OPTIONAL_TYPE>;
|
|
using ImplicitlyUnwrappedOptionalTypeLayout =
|
|
SyntaxSugarTypeLayout<UNCHECKED_OPTIONAL_TYPE>;
|
|
|
|
using DictionaryTypeLayout = BCRecordLayout<
|
|
DICTIONARY_TYPE,
|
|
TypeIDField, // key type
|
|
TypeIDField // value type
|
|
>;
|
|
|
|
using ReferenceStorageTypeLayout = BCRecordLayout<
|
|
REFERENCE_STORAGE_TYPE,
|
|
OwnershipField, // ownership
|
|
TypeIDField // implementation type
|
|
>;
|
|
|
|
using UnboundGenericTypeLayout = BCRecordLayout<
|
|
UNBOUND_GENERIC_TYPE,
|
|
DeclIDField, // generic decl
|
|
TypeIDField // parent
|
|
>;
|
|
|
|
using TypeAliasLayout = BCRecordLayout<
|
|
TYPE_ALIAS_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField,// context decl
|
|
TypeIDField, // underlying type
|
|
TypeIDField, // interface type (no longer used)
|
|
BCFixed<1>, // implicit flag
|
|
GenericEnvironmentIDField, // generic environment
|
|
AccessLevelField, // access level
|
|
BCArray<TypeIDField> // dependency types
|
|
// Trailed by generic parameters (if any).
|
|
>;
|
|
|
|
using GenericTypeParamDeclLayout = BCRecordLayout<
|
|
GENERIC_TYPE_PARAM_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
BCVBR<4>, // depth
|
|
BCVBR<4> // index
|
|
>;
|
|
|
|
using AssociatedTypeDeclLayout = BCRecordLayout<
|
|
ASSOCIATED_TYPE_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
TypeIDField, // default definition
|
|
BCFixed<1>, // implicit flag
|
|
BCArray<DeclIDField> // overridden associated types
|
|
>;
|
|
|
|
using StructLayout = BCRecordLayout<
|
|
STRUCT_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
GenericEnvironmentIDField, // generic environment
|
|
AccessLevelField, // access level
|
|
BCVBR<4>, // number of conformances
|
|
BCArray<TypeIDField> // inherited types
|
|
// Trailed by the generic parameters (if any), the members record, and
|
|
// finally conformance info (if any).
|
|
>;
|
|
|
|
using EnumLayout = BCRecordLayout<
|
|
ENUM_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // raw type
|
|
AccessLevelField, // access level
|
|
BCVBR<4>, // number of conformances
|
|
BCVBR<4>, // number of inherited types
|
|
BCArray<TypeIDField> // inherited types, followed by dependency types
|
|
// Trailed by the generic parameters (if any), the members record, and
|
|
// finally conformance info (if any).
|
|
>;
|
|
|
|
using ClassLayout = BCRecordLayout<
|
|
CLASS_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField,// context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // explicitly objc?
|
|
BCFixed<1>, // requires stored property initial values
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // superclass
|
|
AccessLevelField, // access level
|
|
BCVBR<4>, // number of conformances
|
|
BCArray<TypeIDField> // inherited types
|
|
// Trailed by the generic parameters (if any), the members record, and
|
|
// finally conformance info (if any).
|
|
>;
|
|
|
|
using ProtocolLayout = BCRecordLayout<
|
|
PROTOCOL_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
BCFixed<1>, // class-bounded?
|
|
BCFixed<1>, // objc?
|
|
BCFixed<1>, // existential-type-supported?
|
|
GenericEnvironmentIDField, // generic environment
|
|
AccessLevelField, // access level
|
|
BCArray<DeclIDField> // inherited types
|
|
// Trailed by the generic parameters (if any), the members record, and
|
|
// the default witness table record
|
|
>;
|
|
|
|
/// A default witness table for a protocol.
|
|
using DefaultWitnessTableLayout = BCRecordLayout<
|
|
DEFAULT_WITNESS_TABLE,
|
|
BCArray<DeclIDField>
|
|
// An array of requirement / witness pairs
|
|
>;
|
|
|
|
using ConstructorLayout = BCRecordLayout<
|
|
CONSTRUCTOR_DECL,
|
|
DeclContextIDField, // context decl
|
|
OptionalTypeKindField, // failability
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // objc?
|
|
BCFixed<1>, // stub implementation?
|
|
BCFixed<1>, // throws?
|
|
CtorInitializerKindField, // initializer kind
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // interface type
|
|
DeclIDField, // overridden decl
|
|
AccessLevelField, // access level
|
|
BCFixed<1>, // requires a new vtable slot
|
|
BCFixed<1>, // default argument resilience expansion
|
|
BCFixed<1>, // 'required' but overridden is not (used for recovery)
|
|
BCVBR<5>, // number of parameter name components
|
|
BCArray<IdentifierIDField> // name components,
|
|
// followed by TypeID dependencies
|
|
// Trailed by its generic parameters, if any, followed by the parameter
|
|
// patterns.
|
|
>;
|
|
|
|
using VarLayout = BCRecordLayout<
|
|
VAR_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // explicitly objc?
|
|
BCFixed<1>, // static?
|
|
VarDeclSpecifierField, // specifier
|
|
BCFixed<1>, // HasNonPatternBindingInit?
|
|
BCFixed<1>, // is getter mutating?
|
|
BCFixed<1>, // is setter mutating?
|
|
StorageKindField, // StorageKind
|
|
TypeIDField, // interface type
|
|
DeclIDField, // getter
|
|
DeclIDField, // setter
|
|
DeclIDField, // materializeForSet
|
|
DeclIDField, // addressor
|
|
DeclIDField, // mutableAddressor
|
|
DeclIDField, // willset
|
|
DeclIDField, // didset
|
|
DeclIDField, // overridden decl
|
|
AccessLevelField, // access level
|
|
AccessLevelField, // setter access, if applicable
|
|
BCArray<TypeIDField> // dependencies
|
|
>;
|
|
|
|
using ParamLayout = BCRecordLayout<
|
|
PARAM_DECL,
|
|
IdentifierIDField, // argument name
|
|
IdentifierIDField, // parameter name
|
|
DeclContextIDField, // context decl
|
|
VarDeclSpecifierField, // specifier
|
|
TypeIDField // interface type
|
|
>;
|
|
|
|
using FuncLayout = BCRecordLayout<
|
|
FUNC_DECL,
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // is 'static' or 'class'?
|
|
StaticSpellingKindField, // spelling of 'static' or 'class'
|
|
BCFixed<1>, // explicitly objc?
|
|
SelfAccessKindField, // self access kind
|
|
BCFixed<1>, // has dynamic self?
|
|
BCFixed<1>, // has forced static dispatch?
|
|
BCFixed<1>, // throws?
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // interface type
|
|
DeclIDField, // operator decl
|
|
DeclIDField, // overridden function
|
|
BCVBR<5>, // 0 for a simple name, otherwise the number of parameter name
|
|
// components plus one
|
|
AccessLevelField, // access level
|
|
BCFixed<1>, // requires a new vtable slot
|
|
BCFixed<1>, // default argument resilience expansion
|
|
BCArray<IdentifierIDField> // name components,
|
|
// followed by TypeID dependencies
|
|
// The record is trailed by:
|
|
// - its _silgen_name, if any
|
|
// - its generic parameters, if any
|
|
// - body parameter patterns
|
|
>;
|
|
|
|
// TODO: remove the unnecessary FuncDecl components here
|
|
using AccessorLayout = BCRecordLayout<
|
|
ACCESSOR_DECL,
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // is 'static' or 'class'?
|
|
StaticSpellingKindField, // spelling of 'static' or 'class'
|
|
BCFixed<1>, // explicitly objc?
|
|
SelfAccessKindField, // self access kind
|
|
BCFixed<1>, // has dynamic self?
|
|
BCFixed<1>, // has forced static dispatch?
|
|
BCFixed<1>, // throws?
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // interface type
|
|
DeclIDField, // overridden function
|
|
DeclIDField, // AccessorStorageDecl
|
|
AccessorKindField, // accessor kind
|
|
AddressorKindField, // addressor kind
|
|
AccessLevelField, // access level
|
|
BCFixed<1>, // requires a new vtable slot
|
|
BCFixed<1>, // default argument resilience expansion
|
|
BCArray<IdentifierIDField> // name components,
|
|
// followed by TypeID dependencies
|
|
// The record is trailed by:
|
|
// - its _silgen_name, if any
|
|
// - its generic parameters, if any
|
|
// - body parameter patterns
|
|
>;
|
|
|
|
using PatternBindingLayout = BCRecordLayout<
|
|
PATTERN_BINDING_DECL,
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
BCFixed<1>, // static?
|
|
StaticSpellingKindField, // spelling of 'static' or 'class'
|
|
BCVBR<3>, // numpatterns
|
|
BCArray<DeclContextIDField> // init contexts
|
|
// The patterns and decl-contexts trail the record.
|
|
>;
|
|
|
|
template <unsigned Code>
|
|
using UnaryOperatorLayout = BCRecordLayout<
|
|
Code, // ID field
|
|
IdentifierIDField, // name
|
|
DeclContextIDField // context decl
|
|
>;
|
|
|
|
using PrefixOperatorLayout = UnaryOperatorLayout<PREFIX_OPERATOR_DECL>;
|
|
using PostfixOperatorLayout = UnaryOperatorLayout<POSTFIX_OPERATOR_DECL>;
|
|
|
|
using InfixOperatorLayout = BCRecordLayout<
|
|
INFIX_OPERATOR_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField,// context decl
|
|
DeclIDField // precedence group
|
|
>;
|
|
|
|
using PrecedenceGroupLayout = BCRecordLayout<
|
|
PRECEDENCE_GROUP_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField,// context decl
|
|
AssociativityField,// associativity
|
|
BCFixed<1>, // assignment
|
|
BCVBR<2>, // numHigherThan
|
|
BCArray<DeclIDField> // higherThan, followed by lowerThan
|
|
>;
|
|
|
|
using EnumElementLayout = BCRecordLayout<
|
|
ENUM_ELEMENT_DECL,
|
|
IdentifierIDField, // name
|
|
DeclContextIDField,// context decl
|
|
TypeIDField, // interface type
|
|
BCFixed<1>, // has argument type?
|
|
BCFixed<1>, // implicit?
|
|
EnumElementRawValueKindField, // raw value kind
|
|
BCFixed<1>, // negative raw value?
|
|
BCBlob // raw value
|
|
>;
|
|
|
|
using SubscriptLayout = BCRecordLayout<
|
|
SUBSCRIPT_DECL,
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // objc?
|
|
BCFixed<1>, // is getter mutating?
|
|
BCFixed<1>, // is setter mutating?
|
|
StorageKindField, // StorageKind
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField, // interface type
|
|
DeclIDField, // getter
|
|
DeclIDField, // setter
|
|
DeclIDField, // materializeForSet
|
|
DeclIDField, // addressor
|
|
DeclIDField, // mutableAddressor
|
|
DeclIDField, // willSet
|
|
DeclIDField, // didSet
|
|
DeclIDField, // overridden decl
|
|
AccessLevelField, // access level
|
|
AccessLevelField, // setter access, if applicable
|
|
BCVBR<5>, // number of parameter name components
|
|
BCArray<IdentifierIDField> // name components,
|
|
// followed by TypeID dependencies
|
|
// Trailed by:
|
|
// - generic parameters, if any
|
|
// - the indices pattern
|
|
>;
|
|
|
|
using ExtensionLayout = BCRecordLayout<
|
|
EXTENSION_DECL,
|
|
TypeIDField, // base type
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit flag
|
|
GenericEnvironmentIDField, // generic environment
|
|
BCVBR<4>, // # of protocol conformances
|
|
BCVBR<4>, // number of inherited types
|
|
BCArray<TypeIDField> // inherited types, followed by TypeID dependencies
|
|
// Trailed by the generic parameter lists, members record, and then
|
|
// conformance info (if any).
|
|
>;
|
|
|
|
using DestructorLayout = BCRecordLayout<
|
|
DESTRUCTOR_DECL,
|
|
DeclContextIDField, // context decl
|
|
BCFixed<1>, // implicit?
|
|
BCFixed<1>, // objc?
|
|
GenericEnvironmentIDField, // generic environment
|
|
TypeIDField // interface type
|
|
// Trailed by a pattern for self.
|
|
>;
|
|
|
|
using ParameterListLayout = BCRecordLayout<
|
|
PARAMETERLIST,
|
|
BCVBR<5> // numparams
|
|
>;
|
|
|
|
using ParameterListEltLayout = BCRecordLayout<
|
|
PARAMETERLIST_ELT,
|
|
DeclIDField, // ParamDecl
|
|
BCFixed<1>, // isVariadic?
|
|
DefaultArgumentField // default argument
|
|
>;
|
|
|
|
using ParenPatternLayout = BCRecordLayout<
|
|
PAREN_PATTERN,
|
|
BCFixed<1> // implicit?
|
|
// The sub-pattern trails the record.
|
|
>;
|
|
|
|
using TuplePatternLayout = BCRecordLayout<
|
|
TUPLE_PATTERN,
|
|
TypeIDField, // type
|
|
BCVBR<5>, // arity
|
|
BCFixed<1> // implicit?
|
|
// The elements trail the record.
|
|
>;
|
|
|
|
using TuplePatternEltLayout = BCRecordLayout<
|
|
TUPLE_PATTERN_ELT,
|
|
IdentifierIDField // label
|
|
// The element pattern trails the record.
|
|
>;
|
|
|
|
using NamedPatternLayout = BCRecordLayout<
|
|
NAMED_PATTERN,
|
|
DeclIDField, // associated VarDecl
|
|
TypeIDField, // type
|
|
BCFixed<1> // implicit?
|
|
>;
|
|
|
|
using AnyPatternLayout = BCRecordLayout<
|
|
ANY_PATTERN,
|
|
TypeIDField, // type
|
|
BCFixed<1> // implicit?
|
|
// FIXME: is the type necessary?
|
|
>;
|
|
|
|
using TypedPatternLayout = BCRecordLayout<
|
|
TYPED_PATTERN,
|
|
TypeIDField, // associated type
|
|
BCFixed<1> // implicit?
|
|
// The sub-pattern trails the record.
|
|
>;
|
|
|
|
using VarPatternLayout = BCRecordLayout<
|
|
VAR_PATTERN,
|
|
BCFixed<1>, // isLet?
|
|
BCFixed<1> // implicit?
|
|
// The sub-pattern trails the record.
|
|
>;
|
|
|
|
using GenericParamListLayout = BCRecordLayout<
|
|
GENERIC_PARAM_LIST
|
|
// The actual parameters and requirements trail the record.
|
|
>;
|
|
|
|
using GenericParamLayout = BCRecordLayout<
|
|
GENERIC_PARAM,
|
|
DeclIDField // Typealias
|
|
>;
|
|
|
|
using GenericSignatureLayout = BCRecordLayout<
|
|
GENERIC_SIGNATURE,
|
|
BCArray<TypeIDField> // generic parameter types
|
|
>;
|
|
|
|
using SILGenericEnvironmentLayout = BCRecordLayout<
|
|
SIL_GENERIC_ENVIRONMENT,
|
|
BCArray<TypeIDField> // (generic parameter name, sugared interface
|
|
// type) pairs
|
|
>;
|
|
|
|
using GenericRequirementLayout = BCRecordLayout<
|
|
GENERIC_REQUIREMENT,
|
|
GenericRequirementKindField, // requirement kind
|
|
TypeIDField, // types involved (two for conformance,
|
|
TypeIDField // same-type; one for value witness marker)
|
|
>;
|
|
|
|
using LayoutRequirementLayout = BCRecordLayout<
|
|
LAYOUT_REQUIREMENT,
|
|
LayoutRequirementKindField, // requirement kind
|
|
TypeIDField, // type being constrained
|
|
BCFixed<24>, // size
|
|
BCFixed<32> // alignment
|
|
>;
|
|
|
|
/// Specifies the private discriminator string for a private declaration. This
|
|
/// identifies the declaration's original source file in some opaque way.
|
|
using PrivateDiscriminatorLayout = BCRecordLayout<
|
|
PRIVATE_DISCRIMINATOR,
|
|
IdentifierIDField // discriminator string, as an identifier
|
|
>;
|
|
|
|
using LocalDiscriminatorLayout = BCRecordLayout<
|
|
LOCAL_DISCRIMINATOR,
|
|
BCVBR<2> // context-scoped discriminator counter
|
|
>;
|
|
|
|
/// A placeholder for lack of concrete conformance information.
|
|
using AbstractProtocolConformanceLayout = BCRecordLayout<
|
|
ABSTRACT_PROTOCOL_CONFORMANCE,
|
|
DeclIDField // the protocol
|
|
>;
|
|
|
|
using NormalProtocolConformanceLayout = BCRecordLayout<
|
|
NORMAL_PROTOCOL_CONFORMANCE,
|
|
DeclIDField, // the protocol
|
|
DeclContextIDField, // the decl that provided this conformance
|
|
BCVBR<5>, // type mapping count
|
|
BCVBR<5>, // value mapping count
|
|
BCVBR<5>, // requirement signature conformance count
|
|
BCArray<DeclIDField>
|
|
// The array contains type witnesses, then value witnesses.
|
|
// Requirement signature conformances follow, then the substitution records
|
|
// for the associated types.
|
|
>;
|
|
|
|
using SpecializedProtocolConformanceLayout = BCRecordLayout<
|
|
SPECIALIZED_PROTOCOL_CONFORMANCE,
|
|
TypeIDField, // conforming type
|
|
BCVBR<5> // # of substitutions for the conformance
|
|
// followed by substitution records for the conformance
|
|
>;
|
|
|
|
using InheritedProtocolConformanceLayout = BCRecordLayout<
|
|
INHERITED_PROTOCOL_CONFORMANCE,
|
|
TypeIDField // the conforming type
|
|
>;
|
|
|
|
// Refers to a normal protocol conformance in the given module via its id.
|
|
using NormalProtocolConformanceIdLayout = BCRecordLayout<
|
|
NORMAL_PROTOCOL_CONFORMANCE_ID,
|
|
NormalConformanceIDField // the normal conformance ID
|
|
>;
|
|
|
|
using ProtocolConformanceXrefLayout = BCRecordLayout<
|
|
PROTOCOL_CONFORMANCE_XREF,
|
|
DeclIDField, // the protocol being conformed to
|
|
DeclIDField, // the nominal type of the conformance
|
|
ModuleIDField // the module in which the conformance can be found
|
|
>;
|
|
|
|
using MembersLayout = BCRecordLayout<
|
|
MEMBERS,
|
|
BCArray<DeclIDField>
|
|
>;
|
|
|
|
using XRefLayout = BCRecordLayout<
|
|
XREF,
|
|
ModuleIDField, // base module ID
|
|
BCVBR<4> // xref path length (cannot be 0)
|
|
>;
|
|
|
|
using XRefTypePathPieceLayout = BCRecordLayout<
|
|
XREF_TYPE_PATH_PIECE,
|
|
IdentifierIDField, // name
|
|
BCFixed<1> // restrict to protocol extension
|
|
>;
|
|
|
|
using XRefValuePathPieceLayout = BCRecordLayout<
|
|
XREF_VALUE_PATH_PIECE,
|
|
TypeIDField, // type
|
|
IdentifierIDField, // name
|
|
BCFixed<1>, // restrict to protocol extension
|
|
BCFixed<1> // static?
|
|
>;
|
|
|
|
using XRefInitializerPathPieceLayout = BCRecordLayout<
|
|
XREF_INITIALIZER_PATH_PIECE,
|
|
TypeIDField, // type
|
|
BCFixed<1>, // restrict to protocol extension
|
|
CtorInitializerKindField // initializer kind
|
|
>;
|
|
|
|
using XRefExtensionPathPieceLayout = BCRecordLayout<
|
|
XREF_EXTENSION_PATH_PIECE,
|
|
ModuleIDField, // module ID
|
|
GenericSignatureIDField // for a constrained extension,
|
|
// the generic signature
|
|
>;
|
|
|
|
using XRefOperatorOrAccessorPathPieceLayout = BCRecordLayout<
|
|
XREF_OPERATOR_OR_ACCESSOR_PATH_PIECE,
|
|
IdentifierIDField, // name
|
|
AccessorKindField // accessor kind OR operator fixity
|
|
>;
|
|
static_assert(std::is_same<AccessorKindField, OperatorKindField>::value,
|
|
"accessor kinds and operator kinds are not compatible");
|
|
|
|
using XRefGenericParamPathPieceLayout = BCRecordLayout<
|
|
XREF_GENERIC_PARAM_PATH_PIECE,
|
|
BCVBR<5> // index
|
|
>;
|
|
|
|
using SILGenNameDeclAttrLayout = BCRecordLayout<
|
|
SILGenName_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCBlob // _silgen_name
|
|
>;
|
|
|
|
using CDeclDeclAttrLayout = BCRecordLayout<
|
|
CDecl_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCBlob // _silgen_name
|
|
>;
|
|
|
|
|
|
using AlignmentDeclAttrLayout = BCRecordLayout<
|
|
Alignment_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCFixed<31> // alignment
|
|
>;
|
|
|
|
using SwiftNativeObjCRuntimeBaseDeclAttrLayout = BCRecordLayout<
|
|
SwiftNativeObjCRuntimeBase_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
IdentifierIDField // name
|
|
>;
|
|
|
|
using SemanticsDeclAttrLayout = BCRecordLayout<
|
|
Semantics_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCBlob // semantics value
|
|
>;
|
|
|
|
using EffectsDeclAttrLayout = BCRecordLayout<
|
|
Effects_DECL_ATTR,
|
|
BCFixed<2> // modref value
|
|
>;
|
|
|
|
using DeclContextLayout = BCRecordLayout<
|
|
DECL_CONTEXT,
|
|
// If this DeclContext is a local context, this is an
|
|
// index into the local decl context table.
|
|
// If this DeclContext is a Decl (and not a DeclContext
|
|
// *at all*, this is an index into the decl table.
|
|
DeclContextIDField,
|
|
BCFixed<1> // is a decl
|
|
>;
|
|
|
|
using ForeignErrorConventionLayout = BCRecordLayout<
|
|
FOREIGN_ERROR_CONVENTION,
|
|
ForeignErrorConventionKindField, // kind
|
|
BCFixed<1>, // owned
|
|
BCFixed<1>, // replaced
|
|
BCVBR<4>, // error parameter index
|
|
TypeIDField, // error parameter type
|
|
TypeIDField // result type
|
|
>;
|
|
|
|
using AbstractClosureExprLayout = BCRecordLayout<
|
|
ABSTRACT_CLOSURE_EXPR_CONTEXT,
|
|
TypeIDField, // type
|
|
BCFixed<1>, // implicit
|
|
BCVBR<4>, // discriminator
|
|
DeclContextIDField // parent context decl
|
|
>;
|
|
|
|
using TopLevelCodeDeclContextLayout = BCRecordLayout<
|
|
TOP_LEVEL_CODE_DECL_CONTEXT,
|
|
DeclContextIDField // parent context decl
|
|
>;
|
|
|
|
using PatternBindingInitializerLayout = BCRecordLayout<
|
|
PATTERN_BINDING_INITIALIZER_CONTEXT,
|
|
DeclIDField, // parent pattern binding decl
|
|
BCVBR<3> // binding index in the pattern binding decl
|
|
>;
|
|
|
|
using DefaultArgumentInitializerLayout = BCRecordLayout<
|
|
DEFAULT_ARGUMENT_INITIALIZER_CONTEXT,
|
|
DeclContextIDField, // parent context decl
|
|
BCVBR<3> // parameter index
|
|
>;
|
|
|
|
// Stub layouts, unused.
|
|
using OwnershipDeclAttrLayout = BCRecordLayout<Ownership_DECL_ATTR>;
|
|
using RawDocCommentDeclAttrLayout = BCRecordLayout<RawDocComment_DECL_ATTR>;
|
|
using AccessControlDeclAttrLayout = BCRecordLayout<AccessControl_DECL_ATTR>;
|
|
using SetterAccessDeclAttrLayout = BCRecordLayout<SetterAccess_DECL_ATTR>;
|
|
using ObjCBridgedDeclAttrLayout = BCRecordLayout<ObjCBridged_DECL_ATTR>;
|
|
using SynthesizedProtocolDeclAttrLayout
|
|
= BCRecordLayout<SynthesizedProtocol_DECL_ATTR>;
|
|
using ImplementsDeclAttrLayout = BCRecordLayout<Implements_DECL_ATTR>;
|
|
using ObjCRuntimeNameDeclAttrLayout
|
|
= BCRecordLayout<ObjCRuntimeName_DECL_ATTR>;
|
|
using RestatedObjCConformanceDeclAttrLayout
|
|
= BCRecordLayout<RestatedObjCConformance_DECL_ATTR>;
|
|
|
|
using InlineDeclAttrLayout = BCRecordLayout<
|
|
Inline_DECL_ATTR,
|
|
BCFixed<2> // inline value
|
|
>;
|
|
|
|
using OptimizeDeclAttrLayout = BCRecordLayout<
|
|
Optimize_DECL_ATTR,
|
|
BCFixed<2> // optimize value
|
|
>;
|
|
|
|
// Encodes a VersionTuple:
|
|
//
|
|
// Major
|
|
// Minor
|
|
// Subminor
|
|
// HasMinor
|
|
// HasSubminor
|
|
#define BC_AVAIL_TUPLE\
|
|
BCVBR<5>,\
|
|
BCVBR<5>,\
|
|
BCVBR<4>,\
|
|
BCFixed<1>,\
|
|
BCFixed<1>
|
|
|
|
using AvailableDeclAttrLayout = BCRecordLayout<
|
|
Available_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCFixed<1>, // is unconditionally unavailable?
|
|
BCFixed<1>, // is unconditionally deprecated?
|
|
BC_AVAIL_TUPLE, // Introduced
|
|
BC_AVAIL_TUPLE, // Deprecated
|
|
BC_AVAIL_TUPLE, // Obsoleted
|
|
BCVBR<5>, // platform
|
|
BCVBR<5>, // number of bytes in message string
|
|
BCVBR<5>, // number of bytes in rename string
|
|
BCBlob // platform, followed by message
|
|
>;
|
|
|
|
#undef BC_AVAIL_TUPLE
|
|
|
|
using ObjCDeclAttrLayout = BCRecordLayout<
|
|
ObjC_DECL_ATTR,
|
|
BCFixed<1>, // implicit flag
|
|
BCFixed<1>, // Swift 3 inferred
|
|
BCFixed<1>, // implicit name flag
|
|
BCVBR<4>, // # of arguments (+1) or zero if no name
|
|
BCArray<IdentifierIDField>
|
|
>;
|
|
|
|
using SpecializeDeclAttrLayout = BCRecordLayout<
|
|
Specialize_DECL_ATTR,
|
|
BCFixed<1>, // exported flag
|
|
BCFixed<1> // specialization kind
|
|
>;
|
|
|
|
#define SIMPLE_DECL_ATTR(X, CLASS, ...) \
|
|
using CLASS##DeclAttrLayout = BCRecordLayout< \
|
|
CLASS##_DECL_ATTR, \
|
|
BCFixed<1> /* implicit flag */ \
|
|
>;
|
|
#include "swift/AST/Attr.def"
|
|
|
|
}
|
|
|
|
/// Returns the encoding kind for the given decl.
|
|
///
|
|
/// Note that this does not work for all encodable decls, only those designed
|
|
/// to be stored in a hash table.
|
|
static inline decls_block::RecordKind getKindForTable(const Decl *D) {
|
|
using namespace decls_block;
|
|
|
|
switch (D->getKind()) {
|
|
case DeclKind::TypeAlias:
|
|
return decls_block::TYPE_ALIAS_DECL;
|
|
case DeclKind::Enum:
|
|
return decls_block::ENUM_DECL;
|
|
case DeclKind::Struct:
|
|
return decls_block::STRUCT_DECL;
|
|
case DeclKind::Class:
|
|
return decls_block::CLASS_DECL;
|
|
case DeclKind::Protocol:
|
|
return decls_block::PROTOCOL_DECL;
|
|
|
|
case DeclKind::Func:
|
|
return decls_block::FUNC_DECL;
|
|
case DeclKind::Var:
|
|
return decls_block::VAR_DECL;
|
|
case DeclKind::Param:
|
|
return decls_block::PARAM_DECL;
|
|
|
|
case DeclKind::Subscript:
|
|
return decls_block::SUBSCRIPT_DECL;
|
|
case DeclKind::Constructor:
|
|
return decls_block::CONSTRUCTOR_DECL;
|
|
case DeclKind::Destructor:
|
|
return decls_block::DESTRUCTOR_DECL;
|
|
|
|
default:
|
|
llvm_unreachable("cannot store this kind of decl in a hash table");
|
|
}
|
|
}
|
|
|
|
/// The record types within the identifier block.
|
|
///
|
|
/// \sa IDENTIFIER_BLOCK_ID
|
|
namespace identifier_block {
|
|
enum {
|
|
IDENTIFIER_DATA = 1
|
|
};
|
|
|
|
using IdentifierDataLayout = BCRecordLayout<IDENTIFIER_DATA, BCBlob>;
|
|
};
|
|
|
|
/// The record types within the index block.
|
|
///
|
|
/// \sa INDEX_BLOCK_ID
|
|
namespace index_block {
|
|
// These IDs must \em not be renumbered or reordered without incrementing
|
|
// VERSION_MAJOR.
|
|
enum RecordKind {
|
|
TYPE_OFFSETS = 1,
|
|
DECL_OFFSETS,
|
|
IDENTIFIER_OFFSETS,
|
|
TOP_LEVEL_DECLS,
|
|
OPERATORS,
|
|
EXTENSIONS,
|
|
CLASS_MEMBERS_FOR_DYNAMIC_LOOKUP,
|
|
OPERATOR_METHODS,
|
|
|
|
/// The Objective-C method index, which contains a mapping from
|
|
/// Objective-C selectors to the methods/initializers/properties/etc. that
|
|
/// produce Objective-C methods.
|
|
OBJC_METHODS,
|
|
|
|
ENTRY_POINT,
|
|
LOCAL_DECL_CONTEXT_OFFSETS,
|
|
DECL_CONTEXT_OFFSETS,
|
|
LOCAL_TYPE_DECLS,
|
|
GENERIC_ENVIRONMENT_OFFSETS,
|
|
NORMAL_CONFORMANCE_OFFSETS,
|
|
SIL_LAYOUT_OFFSETS,
|
|
|
|
PRECEDENCE_GROUPS,
|
|
NESTED_TYPE_DECLS,
|
|
DECL_MEMBER_NAMES,
|
|
|
|
GENERIC_SIGNATURE_OFFSETS,
|
|
LastRecordKind = GENERIC_SIGNATURE_OFFSETS,
|
|
};
|
|
|
|
constexpr const unsigned RecordIDFieldWidth = 5;
|
|
static_assert(LastRecordKind < (1 << RecordIDFieldWidth),
|
|
"not enough bits for all record kinds");
|
|
using RecordIDField = BCFixed<RecordIDFieldWidth>;
|
|
|
|
using OffsetsLayout = BCGenericRecordLayout<
|
|
RecordIDField, // record ID
|
|
BCArray<BitOffsetField>
|
|
>;
|
|
|
|
using DeclListLayout = BCGenericRecordLayout<
|
|
RecordIDField, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from identifier strings to decl kinds / decl IDs
|
|
>;
|
|
|
|
using GroupNamesLayout = BCGenericRecordLayout<
|
|
RecordIDField, // record ID
|
|
BCBlob // actual names
|
|
>;
|
|
|
|
using ExtensionTableLayout = BCRecordLayout<
|
|
EXTENSIONS, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from identifier strings to decl kinds / decl IDs
|
|
>;
|
|
|
|
using ObjCMethodTableLayout = BCRecordLayout<
|
|
OBJC_METHODS, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from Objective-C selectors to methods with that selector
|
|
>;
|
|
|
|
using NestedTypeDeclsLayout = BCRecordLayout<
|
|
NESTED_TYPE_DECLS, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from identifier strings to decl kinds / decl IDs
|
|
>;
|
|
|
|
using DeclMemberNamesLayout = BCRecordLayout<
|
|
DECL_MEMBER_NAMES, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from member DeclBaseNames to offsets of DECL_MEMBERS records
|
|
>;
|
|
|
|
using EntryPointLayout = BCRecordLayout<
|
|
ENTRY_POINT,
|
|
DeclIDField // the ID of the main class; 0 if there was a main source file
|
|
>;
|
|
}
|
|
|
|
/// \sa DECL_MEMBER_TABLES_BLOCK_ID
|
|
namespace decl_member_tables_block {
|
|
enum RecordKind {
|
|
DECL_MEMBERS = 1,
|
|
};
|
|
|
|
using DeclMembersLayout = BCRecordLayout<
|
|
DECL_MEMBERS, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // maps from DeclIDs to DeclID vectors
|
|
>;
|
|
|
|
}
|
|
|
|
/// \sa COMMENT_BLOCK_ID
|
|
namespace comment_block {
|
|
enum RecordKind {
|
|
DECL_COMMENTS = 1,
|
|
GROUP_NAMES = 2,
|
|
};
|
|
|
|
using DeclCommentListLayout = BCRecordLayout<
|
|
DECL_COMMENTS, // record ID
|
|
BCVBR<16>, // table offset within the blob (see below)
|
|
BCBlob // map from Decl IDs to comments
|
|
>;
|
|
|
|
using GroupNamesLayout = BCRecordLayout<
|
|
GROUP_NAMES, // record ID
|
|
BCBlob // actual names
|
|
>;
|
|
|
|
} // namespace comment_block
|
|
|
|
} // end namespace serialization
|
|
} // end namespace swift
|
|
|
|
#endif
|