//===--- Builtins.def - Builtins Macro Metaprogramming Database -*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2022 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the database of builtin functions.
//
// BUILTIN(Id, Name, Attrs)
//   - Id is an identifier suitable for use in C++
//   - Name is a string literal for the name to which the builtin should be
//     bound in Swift
//   - Attrs specifies information about attributes of the function:
//     n -> readnone
//
//===----------------------------------------------------------------------===//

/// Cast operations have type T1 -> T2.
#ifndef BUILTIN_CAST_OPERATION
#define BUILTIN_CAST_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
#endif
BUILTIN_CAST_OPERATION(Trunc   , "trunc",    "n")
BUILTIN_CAST_OPERATION(ZExt    , "zext",     "n")
BUILTIN_CAST_OPERATION(SExt    , "sext",     "n")
BUILTIN_CAST_OPERATION(FPToUI  , "fptoui",   "n")
BUILTIN_CAST_OPERATION(FPToSI  , "fptosi",   "n")
BUILTIN_CAST_OPERATION(UIToFP  , "uitofp",   "n")
BUILTIN_CAST_OPERATION(SIToFP  , "sitofp",   "n")
BUILTIN_CAST_OPERATION(FPTrunc , "fptrunc",  "n")
BUILTIN_CAST_OPERATION(FPExt   , "fpext",    "n")
BUILTIN_CAST_OPERATION(PtrToInt, "ptrtoint", "n")
BUILTIN_CAST_OPERATION(IntToPtr, "inttoptr", "n")
BUILTIN_CAST_OPERATION(BitCast , "bitcast",  "n")

/// Cast-or-bitcast operations have type T1 -> T2.
/// T1 and T2 may be the same size, unlike the corresponding true casts.
#ifndef BUILTIN_CAST_OR_BITCAST_OPERATION
#define BUILTIN_CAST_OR_BITCAST_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
#endif
BUILTIN_CAST_OR_BITCAST_OPERATION(TruncOrBitCast, "truncOrBitCast", "n")
BUILTIN_CAST_OR_BITCAST_OPERATION(ZExtOrBitCast,  "zextOrBitCast",  "n")
BUILTIN_CAST_OR_BITCAST_OPERATION(SExtOrBitCast,  "sextOrBitCast",  "n")

/// Binary operations have type (T,T) -> T.
///
/// We define two different sorts of operations varying when T is static,
/// specifically:
///
/// 1. Overloaded statically typed operations. E.x:
///
///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32.
///
/// 2. Polymorphic typed operations that are valid only in raw SIL. By the time
///    diagnostic constant propagation runs, these must have as its operand a
///    fully specialized type. If the builtin has a type that is not one of its
///    overloaded types, diagnostic constant propagation will emit a diagnostic
///    saying the builtin's type has not been fully resolved. Otherwise,
///    diagnostic constant propagation will transform the builtin to the
///    relevant static overloaded builtin form. E.x.:
///
///       builtin "add"(Self, Self) : Self // *error*
///
///         OR
///
///       builtin "generic_add"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
///         ->
///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
///
/// NOTE: If a polymorphic typed operation is not static by the time guaranteed
/// constant propagation runs, we emit a diagnostic to inform the user (who is
/// assumed to be an expert user) to tell them the value was unspecialized. The
/// typical way this specialization occurs today is via transparent inlining
/// since the transparent inliner devirtualizes and specializes as it goes. Of
/// course this means mandatory inlining must /always/ occur before diagnostic
/// constant propagation.
///
/// NOTE: Often times the builtin infrastructure wants to treat all
/// binary operation builtins generic or not the same way. To ensure
/// we support all use cases in the compiler, we do not declare the
/// operations as part of this builtin since often times this macro is
/// used to generic code. Instead, we stamp this out using the
/// overloaded_static, polymorphic, and all suffixed operations.
#ifndef BUILTIN_BINARY_OPERATION
#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
#endif

#ifdef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
#error "Do not define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR before including this .def file"
#endif

#define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(NAME) #NAME

#ifndef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, Name, Attrs, Overload) \
  BUILTIN_BINARY_OPERATION(Id, Name, Attrs)
#endif

#ifndef BUILTIN_BINARY_OPERATION_POLYMORPHIC
#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(Id, Name) \
  BUILTIN_BINARY_OPERATION(Id, Name, "")
#endif

// TODO: This needs a better name. We stringify generic_ in *_{OVERLOADED_STATIC,POLYMORPHIC}
#ifndef BUILTIN_BINARY_OPERATION_ALL
#define BUILTIN_BINARY_OPERATION_ALL(Id, Name, Attrs, Overload) \
  BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(Name), Attrs, Overload) \
  BUILTIN_BINARY_OPERATION_POLYMORPHIC(Generic##Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(generic_##Name))
#endif

// NOTE: Here we need our name field to be bare. We stringify them as
// appropriately in BUILTIN_BINARY_OPERATION_{OVERLOADED_STATIC,POLYMORPHIC}.
BUILTIN_BINARY_OPERATION_ALL(Add,     add,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(FAdd,    fadd,     "n", FloatOrVector)
BUILTIN_BINARY_OPERATION_ALL(And,     and,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(AShr,    ashr,     "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(LShr,    lshr,     "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(Or,      or,       "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(FDiv,    fdiv,     "n", FloatOrVector)
BUILTIN_BINARY_OPERATION_ALL(Mul,     mul,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(FMul,    fmul,     "n", FloatOrVector)
BUILTIN_BINARY_OPERATION_ALL(SDiv,    sdiv,     "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(ExactSDiv, sdiv_exact, "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(Shl,     shl,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(SRem,    srem,     "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(Sub,     sub,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(FSub,    fsub,     "n", FloatOrVector)
BUILTIN_BINARY_OPERATION_ALL(UDiv,    udiv,     "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(ExactUDiv, udiv_exact, "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_ALL(URem,    urem,     "n", Integer)
BUILTIN_BINARY_OPERATION_ALL(FRem,    frem,     "n", FloatOrVector)
BUILTIN_BINARY_OPERATION_ALL(Xor,     xor,      "n", IntegerOrVector)
BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Expect, "int_expect", "n", Integer)

/// These builtins are analogous the similarly named llvm intrinsics. The
/// difference between the two is that these are not expected to overflow,
/// so we should produce a compile time error if we can statically prove
/// that they do.
#ifndef BUILTIN_BINARY_OPERATION_WITH_OVERFLOW
#define BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(Id, Name, UncheckedID, Attrs, Overload) \
          BUILTIN(Id, Name, Attrs)
#endif
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(SAddOver,
                                       "sadd_with_overflow", Add, "n", Integer)
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(UAddOver,
                                       "uadd_with_overflow", Add, "n", Integer)
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(SSubOver,
                                       "ssub_with_overflow", Sub, "n", Integer)
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(USubOver,
                                       "usub_with_overflow", Sub, "n", Integer)
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(SMulOver,
                                       "smul_with_overflow", Mul, "n", Integer)
BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(UMulOver,
                                       "umul_with_overflow", Mul, "n", Integer)

/// Unary operations have type (T) -> T.
#ifndef BUILTIN_UNARY_OPERATION
#define BUILTIN_UNARY_OPERATION(Id, Name, Attrs, Overload) \
          BUILTIN(Id, Name, Attrs)
#endif

// "fneg" is a separate builtin because its LLVM representation is
// 'fsub -0.0, %x', but defining it in swift as
// 'func [prefix] -(x) { -0.0 - x }' would be infinitely recursive.
BUILTIN_UNARY_OPERATION(FNeg, "fneg", "n", FloatOrVector)

// Returns the argument and specifies that the value is not negative.
// It has only an effect if the argument is a load or call.
// TODO: consider printing a warning if it is not used on a load or call.
BUILTIN_UNARY_OPERATION(AssumeNonNegative, "assumeNonNegative", "n", Integer)
// It only works on i1.
BUILTIN_UNARY_OPERATION(AssumeTrue, "assume", "", Integer)
// Converts poison/undef to an indeterminate but valid value.
BUILTIN_UNARY_OPERATION(Freeze, "freeze", "n", IntegerOrVector)

// Binary predicates have type (T,T) -> i1 or (T, T) -> Vector<i1> for scalars
// and vectors, respectively.
#ifndef BUILTIN_BINARY_PREDICATE
#define BUILTIN_BINARY_PREDICATE(Id, Name, Attrs, Overload) \
          BUILTIN(Id, Name, Attrs)
#endif
BUILTIN_BINARY_PREDICATE(ICMP_EQ,  "cmp_eq",   "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_NE,  "cmp_ne",   "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_SLE, "cmp_sle",  "n", IntegerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_SLT, "cmp_slt",  "n", IntegerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_SGE, "cmp_sge",  "n", IntegerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_SGT, "cmp_sgt",  "n", IntegerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_ULE, "cmp_ule",  "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_ULT, "cmp_ult",  "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_UGE, "cmp_uge",  "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(ICMP_UGT, "cmp_ugt",  "n", IntegerOrRawPointerOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_OEQ, "fcmp_oeq", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_OGT, "fcmp_ogt", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_OGE, "fcmp_oge", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_OLT, "fcmp_olt", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_OLE, "fcmp_ole", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_ONE, "fcmp_one", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_ORD, "fcmp_ord", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_UEQ, "fcmp_ueq", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_UGT, "fcmp_ugt", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_UGE, "fcmp_uge", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_ULT, "fcmp_ult", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_ULE, "fcmp_ule", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_UNE, "fcmp_une", "n", FloatOrVector)
BUILTIN_BINARY_PREDICATE(FCMP_UNO, "fcmp_uno", "n", FloatOrVector)

// BUILTIN_SIL_OPERATION - Operations that can be lowered to SIL instructions.
// These have various types.
// Since these operations will be lowered to SIL Instructions, we do not
// assign any attributes on them.
#ifndef BUILTIN_SIL_OPERATION
#define BUILTIN_SIL_OPERATION(Id, Name, Overload) BUILTIN(Id, Name, "")
#endif

/// retain: T -> ()
BUILTIN_SIL_OPERATION(Retain, "retain", Special)

/// release: T -> ()
BUILTIN_SIL_OPERATION(Release, "release", Special)

/// autorelease: T -> ()
BUILTIN_SIL_OPERATION(Autorelease, "autorelease", Special)

/// Load has type (Builtin.RawPointer) -> T
BUILTIN_SIL_OPERATION(Load, "load", Special)

/// LoadRaw has type (Builtin.RawPointer) -> T
/// This is a load of T from raw memory.
/// Its address does not adhere to strict aliasing.
BUILTIN_SIL_OPERATION(LoadRaw, "loadRaw", Special)

/// LoadInvariant has type (Builtin.RawPointer) -> T
/// This is a load of T from raw memory.
/// The load is marked as invariant.
BUILTIN_SIL_OPERATION(LoadInvariant, "loadInvariant", Special)

/// Take has type (Builtin.RawPointer) -> T
BUILTIN_SIL_OPERATION(Take, "take", Special)

/// Destroy has type (T.Type, Builtin.RawPointer) -> ()
BUILTIN_SIL_OPERATION(Destroy, "destroy", Special)

/// Assign has type (T, Builtin.RawPointer) -> ()
BUILTIN_SIL_OPERATION(Assign, "assign", Special)

/// Init has type (T, Builtin.RawPointer) -> ()
BUILTIN_SIL_OPERATION(Init, "initialize", Special)

/// StoreRaw has type (T, Builtin.RawPointer) -> ()
/// Stores a T to raw memory.
/// Its address does not adhere to strict aliasing.
/// See also LoadRaw.
BUILTIN_SIL_OPERATION(StoreRaw, "storeRaw", Special)

/// CastToNativeObject has type (T) -> Builtin.NativeObject.
///
/// This builtin asserts if the underlying type /could/ be objc.
BUILTIN_SIL_OPERATION(CastToNativeObject, "castToNativeObject", Special)

/// UnsafeCastToNativeObject has type (T) -> Builtin.NativeObject.
///
/// This builtin does not check if the underlying type /could/ be objc.
BUILTIN_SIL_OPERATION(UnsafeCastToNativeObject, "unsafeCastToNativeObject", Special)

/// CastFromNativeObject has type (Builtin.NativeObject) -> T
BUILTIN_SIL_OPERATION(CastFromNativeObject, "castFromNativeObject", Special)

/// CastToBridgeObject has type (T, Builtin.Word) -> Builtin.BridgeObject.
/// It sets the BridgeObject to the bitwise OR of its operands.
/// It is assumed that
///
///   castReferenceFromBridgeObject(castToBridgeObject(ref, x)) === ref
///
/// regardless of what x is.
/// x thus must not have any bits set that would change the heap
/// object pointer value, nor may it have the native/ObjC discriminator bit set,
/// nor may it have any bits set if the first operand is an ObjC tagged pointer,
/// or else undefined behavior will ensue.
BUILTIN_SIL_OPERATION(CastToBridgeObject, "castToBridgeObject", Special)

/// ValueToBridgeObject has type (T) -> Builtin.BridgeObject.
/// It sets the BridgeObject to a tagged pointer representation holding its
//  operands by tagging and shifting the operand if needed.
///
/// valueToBridgeObject(x) === (x << _swift_abi_ObjCReservedLowBits) |
///     _swift_BridgeObject_TaggedPointerBits
///
/// x thus must not be using any high bits shifted away (via _swift_abi_ObjCReservedLowBits)
/// or the tag bits post-shift.
/// ARC operations on such tagged values are NOPs.
BUILTIN_SIL_OPERATION(ValueToBridgeObject, "valueToBridgeObject", Special)

/// CastReferenceFromBridgeObject has type (Builtin.BridgeObject) -> T.
/// It recovers the heap object reference by masking spare bits from the
/// BridgeObject.
BUILTIN_SIL_OPERATION(CastReferenceFromBridgeObject,
                      "castReferenceFromBridgeObject",
                      Special)

/// CastBitPatternFromBridgeObject has type (Builtin.BridgeObject) -> Builtin.Word.
/// It presents the raw bit pattern of the BridgeObject as
BUILTIN_SIL_OPERATION(CastBitPatternFromBridgeObject,
                      "castBitPatternFromBridgeObject",
                      Special)

/// ClassifyBridgeObject has type:
///      (Builtin.BridgeObject) -> (Builtin.Int1, Builtin.Int1).
/// It interprets the bits mangled into a bridge object, returning whether it is
/// an Objective-C object or tagged pointer representation.
BUILTIN_SIL_OPERATION(ClassifyBridgeObject, "classifyBridgeObject", Special)


/// BridgeToRawPointer has type (T) -> Builtin.RawPointer
BUILTIN_SIL_OPERATION(BridgeToRawPointer, "bridgeToRawPointer", Special)

/// BridgeFromRawPointer (Builtin.RawPointer) -> T
/// SILGen requires that T is a single retainable pointer.
/// Bridging to/from a raw pointer does not imply a retain.
BUILTIN_SIL_OPERATION(BridgeFromRawPointer, "bridgeFromRawPointer", Special)

/// castReference has type T -> U.
/// T and U must be convertible to AnyObject.
BUILTIN_SIL_OPERATION(CastReference, "castReference", Special)

/// reinterpretCast has type T -> U.
BUILTIN_SIL_OPERATION(ReinterpretCast, "reinterpretCast", Special)

/// addressof (inout T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a physical lvalue. The returned pointer is
/// only valid for the duration of the original binding.
BUILTIN_SIL_OPERATION(AddressOf, "addressof", Special)

/// unprotectedAddressOf (inout T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a physical lvalue. The returned pointer is
/// only valid for the duration of the original binding.
/// In contrast to `addressof`, this builtin doesn't trigger an insertion of
/// stack protectors.
BUILTIN_SIL_OPERATION(UnprotectedAddressOf, "unprotectedAddressOf", Special)

/// addressOfBorrow (__shared T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a borrowed rvalue. The returned pointer is only
/// valid within the scope of the borrow.
BUILTIN_SIL_OPERATION(AddressOfBorrow, "addressOfBorrow", Special)

/// unprotectedAddressOfBorrow (__shared T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a borrowed rvalue. The returned pointer is only
/// valid within the scope of the borrow.
/// In contrast to `addressOfBorrow`, this builtin doesn't trigger an insertion of
/// stack protectors.
BUILTIN_SIL_OPERATION(UnprotectedAddressOfBorrow, "unprotectedAddressOfBorrow", Special)

/// GepRaw(Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer
///
/// Adds index bytes to a base pointer.
BUILTIN_SIL_OPERATION(GepRaw, "gepRaw", Integer)

/// Gep (Builtin.RawPointer, Builtin.Word, T.Type) -> Builtin.RawPointer
///
/// Like the GepRaw-builtin, but multiplies the index by stride-of type 'T'.
BUILTIN_SIL_OPERATION(Gep, "gep", Integer)

/// getTailAddr(Builtin.RawPointer,
///             Builtin.Word, T.Type, E.Type) -> Builtin.RawPointer
///
/// Like the Gep-builtin, but rounds up the resulting address to a tail-
/// allocated element type 'E'.
BUILTIN_SIL_OPERATION(GetTailAddr, "getTailAddr", Integer)

/// performInstantaneousReadAccess(Builtin.RawPointer, T.Type) -> ()
/// Begin and then immediately end a read access to the given raw pointer,
/// which will be treated as an address of type 'T'.
BUILTIN_SIL_OPERATION(PerformInstantaneousReadAccess,
                      "performInstantaneousReadAccess", Special)

/// beginUnpairedModifyAccess(Builtin.RawPointer, Builtin.RawPointer,
///                           T.Type) -> ()
/// Begins but does not end a 'modify' access to the first raw pointer argument.
/// The second raw pointer must be a pointer to an UnsafeValueBuffer, which
/// will be used by the runtime to record the access. The lifetime of the
/// value buffer must be longer than that of the access itself. The accessed
/// address will be treated as having type 'T'.
BUILTIN_SIL_OPERATION(BeginUnpairedModifyAccess, "beginUnpairedModifyAccess",
                      Special)

/// endUnpairedAccess(Builtin.RawPointer) -> ()
/// Ends an in-progress unpaired access. The raw pointer argument must be
/// be a pointer to an UnsafeValueBuffer that records an in progress access.
BUILTIN_SIL_OPERATION(EndUnpairedAccess, "endUnpairedAccess", Special)

/// condfail(Int1) -> ()
/// Triggers a runtime failure if the condition is true.
/// This builtin is deprecated. Use condfail_message instead.
BUILTIN_SIL_OPERATION(LegacyCondFail, "condfail", Special)

/// fixLifetime(T) -> ()
/// Fixes the lifetime of any heap references in a value.
BUILTIN_SIL_OPERATION(FixLifetime, "fixLifetime", Special)

/// isUnique : <T> (inout T[?]) -> Int1
///
/// This builtin takes an inout object reference and returns a boolean. Passing
/// the reference inout forces the optimizer to preserve a retain distinct from
/// what's required to maintain lifetime for any of the reference's source-level
/// copies, because the called function is allowed to replace the reference,
/// thereby releasing the referent.
///
/// The kind of reference count checking that Builtin.isUnique performs depends
/// on the argument type:
///
/// - Native object types are directly checked by reading the
///   strong reference count:
///   (Builtin.NativeObject, known native class reference)
///
/// - Objective-C object types require an additional check that the
///   dynamic object type uses native swift reference counting:
///   (AnyObject, unknown class reference, class existential)
///
/// - Bridged object types allow the dynamic object type check to be
///   passed based on their pointer encoding:
///   (Builtin.BridgeObject)
///
/// Any of the above types may also be wrapped in an optional.
/// If the static argument type is optional, then a null check is also
/// performed.
///
/// Thus, isUnique only returns true for non-null, native swift object
/// references with a strong reference count of one.
BUILTIN_SIL_OPERATION(IsUnique, "isUnique", Special)

/// IsUnique_native : <T> (inout T[?]) -> Int1
///
/// These variants of isUnique implicitly cast to a non-null NativeObject before
/// checking uniqueness. This allows an object reference statically typed as
/// BridgeObject to be treated as a native object by the runtime.
BUILTIN_SIL_OPERATION(IsUnique_native, "isUnique_native", Special)

/// beginCOWMutation<T : AnyObject>(inout T) -> Int1
///
/// Begins a copy-on-write mutation for a buffer reference which is passed as
/// inout argument. It returns a true if the buffer is uniquely referenced.
/// In this case the buffer may be mutated after calling this builtin.
///
/// The beginCOWMutation builtin is very similar to isUnique. It just translates
/// to a different SIL instruction (begin_cow_mutation), which is the preferred
/// representation of COW in SIL.
BUILTIN_SIL_OPERATION(BeginCOWMutation, "beginCOWMutation", Special)

/// beginCOWMutation_native<T : AnyObject>(inout T) -> Int1
///
/// Like beginCOWMutation, but it's assumed that T has native Swift reference
/// counting.
BUILTIN_SIL_OPERATION(BeginCOWMutation_native, "beginCOWMutation_native", Special)

/// endCOWMutation<T : AnyObject>(inout T)
///
/// Ends a copy-on-write mutation for a buffer reference which is passed as
/// inout argument. After calling this builtin, the buffer must not be mutated.
BUILTIN_SIL_OPERATION(EndCOWMutation, "endCOWMutation", Special)

/// bindMemory : <T> (Builtin.RawPointer, Builtin.Word, T.Type) -> Builtin.Word
///
/// Binds memory to a statically known type. Returns an opaque token
/// representing the memory region's previously bound types.
BUILTIN_SIL_OPERATION(BindMemory, "bindMemory", Special)

/// rebindMemory : (Builtin.RawPointer, Builtin.Word) -> Builtin.Word
///
/// Binds memory to the types represented by an opaque token operand. Returns an
/// opaque token representing the memory region's previously bound types.
BUILTIN_SIL_OPERATION(RebindMemory, "rebindMemory", Special)

/// allocWithTailElems_<n>(C.Type,
///                    Builtin.Word, E1.Type, ... , Builtin.Word, En.Type) -> C\
///
/// The integer suffix <n> specifies the number of tail-allocated arrays.
/// Each tail-allocated array adds a counter and an element meta-type parameter.
BUILTIN_SIL_OPERATION(AllocWithTailElems, "allocWithTailElems", Special)

/// projectTailElems : <C,E> (C) -> Builtin.RawPointer
///
/// Projects the first tail-allocated element of type E from a class C.
BUILTIN_SIL_OPERATION(ProjectTailElems, "projectTailElems", Special)

/// Unsafely convert a value of type T to an unowned value.
///
/// It has type (T, @inout @unowned(unsafe) T) -> (). The reason for the weird
/// signature is to work around issues with results in SILGen builtin emission.
BUILTIN_SIL_OPERATION(ConvertStrongToUnownedUnsafe, "convertStrongToUnownedUnsafe", Special)

/// Unsafely convert a value of type @inout @unowned(unsafe) T to a loaded
/// guaranteed T value that has a lifetime guaranteed by the passed in base
/// value of type BaseTy.
///
/// It has type (@in_guaranteed BaseTy, @in_guaranteed @unowned (unsafe) T) -> @guaranteed T.
///
/// NOTE: Saying the result is a guaranteed T is a bit of a misnomer. We aren't
/// emitting a builtin call, but are just emitting SIL directly.
///
/// NOTE: Even though the signature is as mentioned above, we actually tell the
/// AST we have the signature:
///
///   <BaseT, T, U> (BaseT, T) -> U
///
/// We then perform the actual type checking in SILGen and assert on
/// failure. This is an early, unsupported feature so this is sufficient for
/// now.
BUILTIN_SIL_OPERATION(ConvertUnownedUnsafeToGuaranteed, "convertUnownedUnsafeToGuaranteed", Special)

/// applyDerivative
BUILTIN_SIL_OPERATION(ApplyDerivative, "applyDerivative", Special)

/// applyTranspose
BUILTIN_SIL_OPERATION(ApplyTranspose, "applyTranspose", Special)

/// withUnsafeContinuation<T> : (Builtin.RawUnsafeContinuation -> ()) async -> sending T
///
/// Unsafely capture the current continuation and pass it to the given
/// function value. Returns a value of type T when the continuation is
/// resumed.
BUILTIN_SIL_OPERATION(WithUnsafeContinuation, "withUnsafeContinuation", Special)

/// withUnsafeThrowingContinuation<T> : (Builtin.RawUnsafeContinuation -> ()) async throws -> sending T
///
/// Unsafely capture the current continuation and pass it to the given
/// function value. Returns a value of type T or throws an error when
/// the continuation is resumed.
BUILTIN_SIL_OPERATION(WithUnsafeThrowingContinuation, "withUnsafeThrowingContinuation", Special)

/// Force the current task to be rescheduled on the specified actor.
BUILTIN_SIL_OPERATION(HopToActor, "hopToActor", None)

/// packLength: <each T>(_: repeat each T) -> Int
///
/// Returns the number of items in a pack.
BUILTIN_SIL_OPERATION(PackLength, "packLength", Special)

// BUILTIN_RUNTIME_CALL - A call into a runtime function.
// These functions accept a single argument of any type.
#ifndef BUILTIN_RUNTIME_CALL
#define BUILTIN_RUNTIME_CALL(Id, Name, Attrs) \
  BUILTIN(Id, Name, Attrs)
#endif

/// unexpectedError: Error -> ()
BUILTIN_RUNTIME_CALL(UnexpectedError, "unexpectedError", "")

/// errorInMain: Error -> ()
BUILTIN_RUNTIME_CALL(ErrorInMain, "errorInMain", "")

/// IsOptionalType : T.Type -> Bool
/// This builtin takes a metatype and returns true if the metatype's
/// nominal type is Optional.
BUILTIN_RUNTIME_CALL(IsOptionalType, "isOptional", "")

// BUILTIN_MISC_OPERATION - Miscellaneous operations without a unifying class.
// These have various types.
#ifndef BUILTIN_MISC_OPERATION
#define BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload) \
          BUILTIN(Id, Name, Attrs)
#endif

/// condfail_message(Int1, RawPointer) -> ()
/// Triggers a runtime failure if the condition is true.
BUILTIN_MISC_OPERATION(CondFailMessage, "condfail_message", "", Special)

/// IsPOD has type T.Type -> Bool
BUILTIN_MISC_OPERATION(IsPOD, "ispod", "n", Special)

/// IsConcrete has type (T.Type) -> Bool
///
/// If the meta type T is concrete, we can always transform this to `true` at
/// any time in SIL. If it's generic, then we lower it to `false` right before
/// IRGen in IRGenPrepare. This allows for the optimizer to specialize this at
/// -O and eliminate conditional code.
BUILTIN_MISC_OPERATION(IsConcrete, "isConcrete", "n", Special)

/// IsBitwiseTakable has type T.Type -> Bool
BUILTIN_MISC_OPERATION(IsBitwiseTakable, "isbitwisetakable", "n", Special)

/// IsSameMetatype has type (Any.Type, Any.Type) -> Bool
BUILTIN_MISC_OPERATION(IsSameMetatype, "is_same_metatype", "n", Special)

/// AllocRaw has type (Int, Int) -> Builtin.RawPointer
///
/// Parameters: object size, object alignment.
///
/// This alignment is not a mask; the compiler decrements by one to provide
/// a mask to the runtime.
///
/// If alignment == 0, then the runtime will use "aligned" allocation,
/// and the memory will be aligned to _swift_MinAllocationAlignment.
BUILTIN_MISC_OPERATION(AllocRaw, "allocRaw", "", Special)

/// DeallocRaw has type (Builtin.RawPointer, Int, Int) -> ()
///
/// Parameters: object address, object size, object alignment.
///
/// This alignment is not a mask; the compiler decrements by one to provide
/// a mask to the runtime.
///
/// If alignment == 0, then the runtime will use the "aligned" deallocation
/// path, which assumes that "aligned" allocation was used.
///
/// Note that the alignment value provided to `deallocRaw` must be identical to
/// the alignment value provided to `allocRaw` when the memory at this address
/// was allocated.
BUILTIN_MISC_OPERATION(DeallocRaw, "deallocRaw", "", Special)

/// StackAlloc has type (Int, Int, Int) -> Builtin.RawPointer
///
/// Parameters: capacity, stride, alignment
///
/// The resulting pointer comes from the stack (as in the non-standard C
/// extension `alloca()`.) It is at least as aligned as specified and is valid
/// until the end of the calling scope.
///
/// The count and stride are multiplied together to get the byte count to use
/// for the allocation.
///
/// The passed alignment must be a positive power of two. If the alignment value
/// is not known at compile time, MaximumAlignment is assumed.
BUILTIN_MISC_OPERATION(StackAlloc, "stackAlloc", "", Special)

/// Like `stackAlloc`, but doesn't set the `[stack_protection]` flag on its
/// containing function.
BUILTIN_MISC_OPERATION(UnprotectedStackAlloc, "unprotectedStackAlloc", "", Special)

/// StackDealloc has type (Builtin.RawPointer) -> ()
///
/// Parameters: address.
///
/// The range starting at `address`, previously allocated with
/// Builtin.stackAlloc(), is deallocated from the stack.
BUILTIN_MISC_OPERATION(StackDealloc, "stackDealloc", "", Special)

/// allocVector<Element>(Element.Type, Builtin.Word) -> Builtin.RawPointer
BUILTIN_MISC_OPERATION(AllocVector, "allocVector", "", Special)

/// Fence has type () -> ().
BUILTIN_MISC_OPERATION(Fence, "fence", "", None)

/// onFastPath has type () -> ().
BUILTIN_MISC_OPERATION(OnFastPath, "onFastPath", "n", None)

/// CmpXChg has type (Builtin.RawPointer, T, T) -> (T, Bool).
BUILTIN_MISC_OPERATION(CmpXChg, "cmpxchg", "", Special)

/// AtomicLoad has type (Builtin.RawPointer) -> T.
BUILTIN_MISC_OPERATION(AtomicLoad, "atomicload", "", Special)

/// AtomicStore has type (Builtin.RawPointer, T) -> ().
BUILTIN_MISC_OPERATION(AtomicStore, "atomicstore", "", Special)

/// AtomicRMW has type (Builtin.RawPointer, T) -> T.
BUILTIN_MISC_OPERATION(AtomicRMW, "atomicrmw", "", IntegerOrRawPointer)

/// convertTaskToJob : (Builtin.NativePointer) -> Builtin.Job
///
/// Convert a task pointer into a job pointer.
BUILTIN_MISC_OPERATION(ConvertTaskToJob, "convertTaskToJob", "n", Special)

/// ExtractElement has type (Vector<N, T>, Int32) -> T
BUILTIN_MISC_OPERATION(ExtractElement, "extractelement", "n", Special)

/// InsertElement has type (Vector<N, T>, T, Int32) -> Vector<N, T>.
BUILTIN_MISC_OPERATION(InsertElement, "insertelement", "n", Special)

// Shufflevector has type (VecN<T>, VecN<T>, VecM<Int32>) -> VecM<T>
BUILTIN_MISC_OPERATION(ShuffleVector, "shufflevector", "n", Special)

/// StaticReport has type (Builtin.Int1, Builtin.Int1, Builtin.RawPointer) -> ()
BUILTIN_MISC_OPERATION(StaticReport, "staticReport", "", Special)

/// assert_configuration has type () -> Builtin.Int32
/// Returns the selected assertion configuration.
BUILTIN_MISC_OPERATION(AssertConf, "assert_configuration", "n", Special)

/// Ifdef has type () -> Bool.
BUILTIN_MISC_OPERATION(Ifdef, "ifdef", "n", Special)

/// StringObjectOr has type (T,T) -> T.
/// Sets bits in a string object. The first operand is bit-cast string literal
/// pointer to an integer. The second operand is the bit mask to be or'd into
/// the high bits of the pointer.
/// It is required that the or'd bits are all 0 in the first operand. So this
/// or-operation is actually equivalent to an addition.
BUILTIN_MISC_OPERATION(StringObjectOr,     "stringObjectOr",      "n", Integer)

/// Special truncation builtins that check for sign and overflow errors. These
/// take an integer as an input and return a tuple of the truncated result and
/// an error bit. The name of each builtin is extended with the "from"
/// (sign-agnostic) builtin integer type and the "to" integer type.
/// We require the source type size to be larger than the destination type size
/// (number of bits).
BUILTIN_MISC_OPERATION(UToSCheckedTrunc, "u_to_s_checked_trunc", "n", Special)
BUILTIN_MISC_OPERATION(SToSCheckedTrunc, "s_to_s_checked_trunc", "n", Special)
BUILTIN_MISC_OPERATION(SToUCheckedTrunc, "s_to_u_checked_trunc", "n", Special)
BUILTIN_MISC_OPERATION(UToUCheckedTrunc, "u_to_u_checked_trunc", "n", Special)

/// IntToFPWithOverflow has type (Integer) -> Float
BUILTIN_MISC_OPERATION(IntToFPWithOverflow, "itofp_with_overflow", "n", Special)

/// Builtin.bitWidth_IntLiteral has type
/// (_ value: Builtin.IntLiteral) -> Builtin.Word
BUILTIN_MISC_OPERATION(BitWidth, "bitWidth", "n", Special)

/// Builtin.isNegative_IntLiteral has type
/// (_ value: Builtin.IntLiteral) -> Builtin.Int1
BUILTIN_MISC_OPERATION(IsNegative, "isNegative", "n", Special)

/// Builtin.wordAtIndex_IntLiteral has type
/// (_ value: Builtin.IntLiteral, _ index: Builtin.Word) -> Builtin.Word
BUILTIN_MISC_OPERATION(WordAtIndex, "wordAtIndex", "n", Special)

/// zeroInitializer has type <T> () -> T
BUILTIN_MISC_OPERATION(ZeroInitializer, "zeroInitializer", "n", Special)

/// once has type (Builtin.RawPointer, (Builtin.RawPointer) -> ())
BUILTIN_MISC_OPERATION(Once, "once", "", Special)
/// onceWithContext has type (Builtin.RawPointer, (Builtin.RawPointer) -> (), Builtin.RawPointer)
BUILTIN_MISC_OPERATION(OnceWithContext, "onceWithContext", "", Special)

/// unreachable has type () -> Never
BUILTIN_MISC_OPERATION(Unreachable, "unreachable", "", Special)

/// conditionallyUnreachable has type () -> Never
BUILTIN_MISC_OPERATION(CondUnreachable, "conditionallyUnreachable", "", Special)

/// DestroyArray has type (T.Type, Builtin.RawPointer, Builtin.Word) -> ()
BUILTIN_MISC_OPERATION(DestroyArray, "destroyArray", "", Special)

/// CopyArray, TakeArrayNoAlias, TakeArrayFrontToBack, and TakeArrayBackToFront
/// AssignCopyArrayNoAlias, AssignCopyArrayFrontToBack,
/// AssignCopyArrayBackToFront, AssignTakeArray all have type
/// (T.Type, Builtin.RawPointer, Builtin.RawPointer, Builtin.Word) -> ()
BUILTIN_MISC_OPERATION(CopyArray, "copyArray", "", Special)
BUILTIN_MISC_OPERATION(TakeArrayNoAlias, "takeArrayNoAlias", "", Special)
BUILTIN_MISC_OPERATION(TakeArrayFrontToBack, "takeArrayFrontToBack", "", Special)
BUILTIN_MISC_OPERATION(TakeArrayBackToFront, "takeArrayBackToFront", "", Special)
BUILTIN_MISC_OPERATION(AssignCopyArrayNoAlias, "assignCopyArrayNoAlias", "", Special)
BUILTIN_MISC_OPERATION(AssignCopyArrayFrontToBack, "assignCopyArrayFrontToBack", "", Special)
BUILTIN_MISC_OPERATION(AssignCopyArrayBackToFront, "assignCopyArrayBackToFront", "", Special)
BUILTIN_MISC_OPERATION(AssignTakeArray, "assignTakeArray", "", Special)

/// COWBufferForReading has type <T: AnyObject> T -> T
///
/// Returns the buffer reference which is passed as argument.
/// This builtin indicates to the optimizer that the buffer is not mutable.
BUILTIN_MISC_OPERATION(COWBufferForReading, "COWBufferForReading", "n", Special)

// getObjCTypeEncoding has type <T> T.Type -> RawPointer
BUILTIN_MISC_OPERATION(GetObjCTypeEncoding, "getObjCTypeEncoding", "n", Special)

/// willThrow: Error -> ()
BUILTIN_MISC_OPERATION(WillThrow, "willThrow", "", Special)

/// poundAssert has type (Builtin.Int1, Builtin.RawPointer) -> ().
BUILTIN_MISC_OPERATION(PoundAssert, "poundAssert", "", Special)

// TypePtrAuthDiscriminator has type <T> (T.Type) -> Int64
BUILTIN_MISC_OPERATION(TypePtrAuthDiscriminator, "typePtrAuthDiscriminator", "n", Special)

/// Initialize the default-actor instance in a default actor object.
BUILTIN_MISC_OPERATION(InitializeDefaultActor, "initializeDefaultActor", "", Special)

/// Destroy the default-actor instance in a default actor object.
BUILTIN_MISC_OPERATION(DestroyDefaultActor, "destroyDefaultActor", "", Special)

/// Initialize the extra storage state of a non-default distributed actor object.
BUILTIN_MISC_OPERATION(InitializeNonDefaultDistributedActor,
                       "initializeNonDefaultDistributedActor", "", Special)

/// Allocate a "proxy" for a distributed remote actor.
BUILTIN_MISC_OPERATION(InitializeDistributedRemoteActor,
                       "initializeDistributedRemoteActor", "", Special)

/// Resume a non-throwing continuation normally with the given result.
BUILTIN_MISC_OPERATION(ResumeNonThrowingContinuationReturning,
                       "resumeNonThrowingContinuationReturning", "", Special)

/// targetOSVersionAtLeast has type (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> Builtin.Int32
BUILTIN_MISC_OPERATION(TargetOSVersionAtLeast, "targetOSVersionAtLeast", "n", Special)

/// targetVariantOSVersionAtLeast has type (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> Builtin.Int32
BUILTIN_MISC_OPERATION(TargetVariantOSVersionAtLeast, "targetVariantOSVersionAtLeast", "n", Special)

/// targetOSVersionOrVariantOSVersionAtLeast has type (Builtin.UInt32, Builtin.UInt32, Builtin.UInt32, Builtin.UInt32, Builtin.UInt32, Builtin.UInt32) -> Builtin.UInt32
BUILTIN_MISC_OPERATION(TargetOSVersionOrVariantOSVersionAtLeast, "targetOSVersionOrVariantOSVersionAtLeast", "n", Special)

/// Resume a throwing continuation normally with the given result.
BUILTIN_MISC_OPERATION(ResumeThrowingContinuationReturning,
                       "resumeThrowingContinuationReturning", "", Special)

/// Resume a throwing continuation abnormally with the given error.
BUILTIN_MISC_OPERATION(ResumeThrowingContinuationThrowing,
                       "resumeThrowingContinuationThrowing", "", Special)

/// Create a task group.
BUILTIN_MISC_OPERATION(CreateTaskGroup,
                       "createTaskGroup", "", Special)

/// Create a task group, with options.
BUILTIN_MISC_OPERATION(CreateTaskGroupWithFlags,
                       "createTaskGroupWithFlags", "", Special)

/// Destroy a task group.
BUILTIN_MISC_OPERATION(DestroyTaskGroup,
                       "destroyTaskGroup", "", Special)

/// Unchecked pointer alignment assertion. Allows the compiler to assume
/// alignment of the pointer to emit more efficient code.
///
///   %alignedPtr = builtin "assumeAlignment" (%ptr : $Builtin.RawPointer,
///                                            %alignment : $Builtin.Int)
///                                           : $Builtin.RawPointer
///   %address = pointer_to_address %alignedPtr
///              : $Builtin.RawPointer to [align=1] $*Int
///   %val = load %address : $*Int
///
/// With compile-time knowledge of the value of `%alignment` the compiler can
/// optimize any downstream 'pointer_to_address' instruction by refining its
/// '[align=]' flag . That `[align=]` flag can be used by IRGen to refine the
/// alignment on LLVM load instructions that use the resulting address.
///
/// (Builtin.RawPointer, Builtin.Word) -> Builtin.RawPointer
BUILTIN_MISC_OPERATION(AssumeAlignment, "assumeAlignment", "n", Special)

// BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
// specially emitted during SIL generation.
//
// The intention is that this is meant for builtins that need a named
// builtin representation so one can create a builtin instruction in
// SIL, but that also need special SILGen behavior. If an operation
// just emits custom SIL and does not need to be able to form a
// builtin instruction, please use BUILTIN_SIL_OPERATION.
#ifndef BUILTIN_MISC_OPERATION_WITH_SILGEN
#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload) \
  BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
#endif

/// Sizeof has type T.Type -> Int
BUILTIN_MISC_OPERATION_WITH_SILGEN(Sizeof, "sizeof", "n", Special)

/// Strideof has type T.Type -> Int
BUILTIN_MISC_OPERATION_WITH_SILGEN(Strideof, "strideof", "n", Special)

/// Alignof has type T.Type -> Int
BUILTIN_MISC_OPERATION_WITH_SILGEN(Alignof, "alignof", "n", Special)

// getCurrentExecutor: () async -> Builtin.Executor?
//
// Retrieve the SerialExecutorRef on which the current asynchronous
// function is executing, or nil if the function isn't running
// anywhere in particular.
BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentExecutor, "getCurrentExecutor", "", Special)

// getCurrentAsyncTask: () -> Builtin.NativeObject
//
// Retrieve the pointer to the task in which the current asynchronous
// function is executing.
//
// This is readnone because, within the world modeled by SIL, the
// current async task of a thread never changes.
BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentAsyncTask, "getCurrentAsyncTask", "n", Special)

/// cancelAsyncTask(): (Builtin.NativeObject) -> Void
///
/// Cancel the given asynchronous task.
BUILTIN_MISC_OPERATION_WITH_SILGEN(CancelAsyncTask, "cancelAsyncTask", "", Special)

/// startAsyncLet()<T>: (
///     __owned @escaping () async throws -> sending T
/// ) -> Builtin.RawPointer
///
/// DEPRECATED. startAsyncLetWithLocalBuffer is used instead.
///
/// Create, initialize and start a new async-let and associated task.
/// Returns an AsyncLet* that must be passed to endAsyncLet for destruction.
BUILTIN_MISC_OPERATION(StartAsyncLet, "startAsyncLet", "", Special)

/// startAsyncLetWithLocalBuffer()<T>: (
///     __owned @escaping () async throws -> sending T,
///     _ resultBuf: Builtin.RawPointer
/// ) -> Builtin.RawPointer
///
/// Create, initialize and start a new async-let and associated task, with a
/// locally-allocated buffer assigned to receive the result if the task
/// completes.
/// Returns an AsyncLet* that must be passed to endAsyncLetLifetime for
/// destruction.
BUILTIN_MISC_OPERATION(StartAsyncLetWithLocalBuffer, "startAsyncLetWithLocalBuffer", "", Special)

/// taskRunInline()<T>: (
///     () async -> T
/// ) -> T
///
/// Create an async context inline in the current synchronous context and run
/// the specified closure.
///
/// This is only supported under the task-to-thread concurrency model.
BUILTIN_MISC_OPERATION(TaskRunInline, "taskRunInline", "", Special)

/// flowSensitiveSelfIsolation<T: Actor>(_ actor: T) -> (any Actor)?
///
/// Used only in actor initializers, this builtin lowers to either 'actor'
/// (wrapped in an optional) or 'nil' depending on whether 'self' has been
/// initialized at this point. 'actor' is always an alias for the 'self'
/// being initialized.
BUILTIN_MISC_OPERATION(FlowSensitiveSelfIsolation, "flowSensitiveSelfIsolation", "", Special)

/// flowSensitiveDistributedSelfIsolation<T: DistributedActor>(
///   _ actor: T
/// ) -> (any Actor)?
///
/// Used only in distributed actor initializers, this builtin lowers to either
/// 'actor.asLocalActor' or 'nil' depending on whether 'self' has been
/// initialized at this point. 'actor' is always an alias for the 'self'
/// being initialized.
BUILTIN_MISC_OPERATION(FlowSensitiveDistributedSelfIsolation,
                       "flowSensitiveDistributedSelfIsolation", "", Special)

/// endAsyncLet(): (Builtin.RawPointer) -> Void
///
/// DEPRECATED. The swift_asyncLet_finish intrinsic and endAsyncLetLifetime
/// builtin are used instead.
///
/// Ends and destroys an async-let.
/// The ClosureLifetimeFixup pass adds a second operand to the builtin to
/// ensure that optimizations keep the stack-allocated closure arguments alive
/// until the endAsyncLet.
BUILTIN_MISC_OPERATION_WITH_SILGEN(EndAsyncLet, "endAsyncLet", "", Special)

/// endAsyncLetLifetime(): (Builtin.RawPointer) -> Void
///
/// Marks the end of an async-let's lifetime.
/// The ClosureLifetimeFixup pass adds a second operand to the builtin to
/// ensure that optimizations keep the stack-allocated closure arguments alive
/// until the endAsyncLet.
BUILTIN_MISC_OPERATION(EndAsyncLetLifetime, "endAsyncLetLifetime", "", Special)

/// addressOfBorrowOpaque (__shared T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a borrowed rvalue.  The returned pointer is
/// only valid within the scope of the borrow.  
///
/// Differs from addressOfBorrow only in that it is not lowered until
/// AddressLowering.
BUILTIN_MISC_OPERATION(AddressOfBorrowOpaque, "addressOfBorrowOpaque", "", Special)

/// unprotectedAddressOfBorrowOpaque (__shared T) -> Builtin.RawPointer
/// Returns a RawPointer pointing to a borrowed rvalue. The returned pointer is only
/// valid within the scope of the borrow.
/// In contrast to `addressOfBorrowOpaque`, this builtin doesn't trigger an
/// insertion of stack protectors.
///
/// Differs from unprotectedAddressOfBorrow only in that it is not lowered until
/// AddressLowering.
BUILTIN_MISC_OPERATION(UnprotectedAddressOfBorrowOpaque, "unprotectedAddressOfBorrowOpaque", "", Special)

/// createTask<T>(flags: Int,
///               initialSerialExecutor: (Builtin.Executor)? = nil,
///               taskGroup: Builtin.RawPointer? = nil,
///               initialTaskExecutor: (Builtin.Executor)? = nil,
///               operation: sending @escaping () async throws -> T)
///  -> Builtin.NativeObject, Builtin.RawPointer)
///
/// Create a new task.
BUILTIN_SIL_OPERATION(CreateTask, "createTask", Special)

/// createDiscardingTask(flags: Int,
///                      initialSerialExecutor: (Builtin.Executor)? = nil,
///                      taskGroup: Builtin.RawPointer? = nil,
///                      initialTaskExecutor: (Builtin.Executor)? = nil,
///                      operation: sending @escaping () async throws -> ())
///  -> (Builtin.NativeObject, Builtin.RawPointer)
///
/// Create a new discarding task.
BUILTIN_SIL_OPERATION(CreateDiscardingTask, "createDiscardingTask", Special)

/// createAsyncTask(): (
///     Int,                            // task-creation flags
///     sending @escaping () async throws -> T  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createTask(flags: $0, operation: $1)
BUILTIN_MISC_OPERATION_WITH_SILGEN(CreateAsyncTask,
                                   "createAsyncTask", "", Special)

/// createAsyncTaskInGroup(): (
///     Int,                            // flags
///     Builtin.RawPointer,             // group
///     sending @escaping () async throws -> T  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createTask(flags: $0, taskGroup: $1, operation: $2)
BUILTIN_SIL_OPERATION(CreateAsyncTaskInGroup,
                      "createAsyncTaskInGroup", Special)

/// createAsyncDiscardingTaskInGroup(): (
///     Int,                               // flags
///     Builtin.RawPointer,                // group
///     sending @escaping () async throws -> Void  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createDiscardingTask(flags: $0, taskGroup: $1, operation: $2)
BUILTIN_SIL_OPERATION(CreateAsyncDiscardingTaskInGroup,
                      "createAsyncDiscardingTaskInGroup", Special)

/// createAsyncTaskWithExecutor(): (
///     Int,                            // flags
///     Builtin.Executor,               // executor
///     sending @escaping () async throws -> T  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createTask(flags: $0, initialTaskExecutor: $1, operation: $2)
BUILTIN_SIL_OPERATION(CreateAsyncTaskWithExecutor,
                      "createAsyncTaskWithExecutor", Special)

/// createAsyncTaskInGroupWithExecutor(): (
///     Int,                            // flags
///     Builtin.RawPointer,             // group
///     Builtin.Executor,               // executor
///     sending @escaping () async throws -> T  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createTask(flags: $0, taskGroup: $1, initialTaskExecutor: $2, operation: $3)
BUILTIN_SIL_OPERATION(CreateAsyncTaskInGroupWithExecutor,
                      "createAsyncTaskInGroupWithExecutor", Special)

/// createAsyncDiscardingTaskInGroupWithExecutor(): (
///     Int,                               // flags
///     Builtin.RawPointer,                // group
///     Builtin.Executor,                  // executor
///     sending @escaping () async throws -> Void  // function
/// ) -> Builtin.NativeObject
///
/// Legacy spelling of:
///   createDiscardingTask(flags: $0, taskGroup: $1, initialTaskExecutor: $2,
///                        operation: $3)
BUILTIN_SIL_OPERATION(CreateAsyncDiscardingTaskInGroupWithExecutor,
                      "createAsyncDiscardingTaskInGroupWithExecutor", Special)

/// Build a Builtin.Executor value from an "ordinary" task executor
/// reference.
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinaryTaskExecutorRef,
    "buildOrdinaryTaskExecutorRef", "n", Special)

/// globalStringTablePointer has type String -> Builtin.RawPointer.
/// It returns an immortal, global string table pointer for strings constructed
/// from string literals. We consider it effects as readnone meaning that it
/// does not read any memory (note that even though it reads from a string, it
/// is a pure value and therefore we can consider it as readnone).
BUILTIN_MISC_OPERATION_WITH_SILGEN(GlobalStringTablePointer, "globalStringTablePointer", "n", Special)

// autoDiffCreateLinearMapContextWithType: (T.Type) -> Builtin.NativeObject
BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffCreateLinearMapContextWithType, "autoDiffCreateLinearMapContextWithType", "", Special)

// autoDiffProjectTopLevelSubcontext: (Builtin.NativeObject) -> Builtin.RawPointer
BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffProjectTopLevelSubcontext, "autoDiffProjectTopLevelSubcontext", "n", Special)

// autoDiffAllocateSubcontextWithType: (Builtin.NativeObject, T.Type) -> Builtin.RawPointer
BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffAllocateSubcontextWithType, "autoDiffAllocateSubcontextWithType", "", Special)

/// Build a Builtin.Executor value from an "ordinary" serial executor
/// reference.
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinarySerialExecutorRef,
                                   "buildOrdinarySerialExecutorRef", "n", Special)

/// Build a Builtin.Executor value from an "complex equality" serial executor
/// reference.
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildComplexEqualitySerialExecutorRef,
                                   "buildComplexEqualitySerialExecutorRef", "n", Special)

/// Build a Builtin.Executor value from a default actor reference.
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildDefaultActorExecutorRef,
                                   "buildDefaultActorExecutorRef", "n", Special)

/// Build a Builtin.Executor value for the main actor.
BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildMainActorExecutorRef,
                                   "buildMainActorExecutorRef", "n", Special)

/// extractFunctionIsolation: <T>(_: T) -> (any Actor)?
///
/// Returns the isolation of a value, which must be an @isolated(any)
/// function type.
BUILTIN_MISC_OPERATION_WITH_SILGEN(ExtractFunctionIsolation,
                                   "extractFunctionIsolation", "", Special)

/// getEnumTag: <T>(_: T) -> Builtin.Int32
///
/// Given a dynamic generic value, unsafely assume it is an enum type and call
/// the getEnumTag vwt function.
BUILTIN_MISC_OPERATION_WITH_SILGEN(GetEnumTag, "getEnumTag", "", Special)

/// injectEnumTag: <T>(_: inout T, _: Builtin.Int32) -> ()
///
/// Given a dynamic inout generic value, unsafely assume it is an enum type and
/// inject the given tag into it.
///
/// Note: This assume that either 1. the given tag has no payload or 2. the
/// tag's payload is already initialized with the given source.
BUILTIN_MISC_OPERATION_WITH_SILGEN(InjectEnumTag, "injectEnumTag", "", Special)

/// distributedActorAsAnyActor: <DA: DistributedActor>(_: DA) -> any Actor
///
/// For a given distributed actor that is known to be local, extract an
/// `any Actor` existential that refers to the local actor.
BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActorAsAnyActor", "n", Special)

/// addressOfRawLayout: <T: ~Copyable>(_: borrowing T) -> Builtin.RawPointer
///
/// Returns a raw pointer to the address of the raw layout type. This address is
/// only valid during a borrow access of the raw layout type or until the value
/// is either moved or consumed.
///
/// Note: The purpose of this builtin is to get an opaque pointer to the address
/// of the raw layout type. We explicitly do not want the optimizer looking into
/// this pointer or address thereof to start assuming things about mutability or
/// immutability. This builtin _must_ persist throughout all of SIL and must be
/// lowered away at IRGen, no sooner.
BUILTIN_MISC_OPERATION_WITH_SILGEN(AddressOfRawLayout, "addressOfRawLayout", "n", Special)

/// Builtins for instrumentation added by sanitizers during SILGen.
#ifndef BUILTIN_SANITIZER_OPERATION
#define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
#endif

/// Builtin representing a call to Thread Sanitizer instrumentation.
/// TSanInoutAccess has type (T) -> ()
BUILTIN_SANITIZER_OPERATION(TSanInoutAccess, "tsanInoutAccess", "")

/// Builtins for compile-time type-checking operations used for unit testing.
#ifndef BUILTIN_TYPE_CHECKER_OPERATION
#define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name) BUILTIN(Id, #Name, "n")
#endif

BUILTIN_TYPE_CHECKER_OPERATION(TypeJoin, type_join)
BUILTIN_TYPE_CHECKER_OPERATION(TypeJoinInout, type_join_inout)
BUILTIN_TYPE_CHECKER_OPERATION(TypeJoinMeta, type_join_meta)
BUILTIN_TYPE_CHECKER_OPERATION(TriggerFallbackDiagnostic, trigger_fallback_diagnostic)

// BUILTIN_TYPE_TRAIT_OPERATION - Compile-time type trait operations.
#ifndef BUILTIN_TYPE_TRAIT_OPERATION
#define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name) \
  BUILTIN(Id, #Name, "n")
#endif

/// canBeClass(T.Type) -> Builtin.Int8
/// At compile time, evaluate whether T is or can be bound to a class or
/// @objc protocol type. The answer is a tri-state of 0 = No, 1 = Yes, 2 =
/// Maybe.
BUILTIN_TYPE_TRAIT_OPERATION(CanBeObjCClass, canBeClass)

#undef BUILTIN_TYPE_TRAIT_OPERATION
#undef BUILTIN_UNARY_OPERATION
#undef BUILTIN_BINARY_PREDICATE
#undef BUILTIN_RUNTIME_CALL
#undef BUILTIN_MISC_OPERATION_WITH_SILGEN
#undef BUILTIN_MISC_OPERATION
#undef BUILTIN_SANITIZER_OPERATION
#undef BUILTIN_TYPE_CHECKER_OPERATION
#undef BUILTIN_BINARY_OPERATION_WITH_OVERFLOW
#undef BUILTIN_BINARY_OPERATION_ALL
#undef BUILTIN_BINARY_OPERATION_POLYMORPHIC
#undef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
#undef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
#undef BUILTIN_BINARY_OPERATION
#undef BUILTIN_CAST_OPERATION
#undef BUILTIN_CAST_OR_BITCAST_OPERATION
#undef BUILTIN_SIL_OPERATION
#undef BUILTIN
