//===--- SILNodes.def - Swift SIL Metaprogramming ---------------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines macros used for macro-metaprogramming with SIL nodes.
//
//===----------------------------------------------------------------------===//

/// NODE(ID, PARENT)
///
///   A concrete subclass of SILNode.  ID is the name of the class as well
///   as a member of SILNodeKind.  PARENT is the name of its abstract
///   superclass.
#ifndef NODE
#define NODE(ID, PARENT)
#endif

/// SINGLE_VALUE_INST(Id, Parent, TextualName, MemBehavior, MayRelease)
///
///   A concrete subclass of SingleValueInstruction, which inherits from
///   both ValueBase and SILInstruction.  ID is a member of both ValueKind
///   and SILInstructionKind.
#ifndef SINGLE_VALUE_INST
#ifdef VALUE
#define SINGLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
  VALUE(ID, PARENT)
#else
#define SINGLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
  FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
#endif
#endif

/// MULTIPLE_VALUE_INST(Id, TextualName, Parent, MemBehavior, MayRelease)
///
///   A concrete subclass of MultipleValueInstruction. ID is a member of
///   SILInstructionKind. The Node's class name is ID and the name of the base
///   class in the heirarchy is PARENT.
#ifndef MULTIPLE_VALUE_INST
#define MULTIPLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
  FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
#endif

/// MULTIPLE_VALUE_INST_RESULT(ID, PARENT)
///
///   A concrete subclass of MultipleValueInstructionResult. ID is a member of
///   ValueKind. The Node's class name is ID and the name of the base class in
///   the heirarchy is PARENT.
#ifndef MULTIPLE_VALUE_INST_RESULT
#define MULTIPLE_VALUE_INST_RESULT(ID, PARENT) VALUE(ID, PARENT)
#endif

/// VALUE(ID, PARENT)
///
///   A concrete subclass of ValueBase.  ID is a member of ValueKind.
///   ID is a member of ValueKind.  The node's class name is
///   Id, and the name of its base class (in the SILValue hierarchy) is Parent.
#ifndef VALUE
#define VALUE(ID, PARENT) NODE(ID, PARENT)
#endif

/// ARGUMENT(ID, PARENT)
///
///   A concrete subclass of SILArgument, which is a subclass of ValueBase.
#ifndef ARGUMENT
#define ARGUMENT(ID, PARENT) VALUE(ID, PARENT)
#endif

/// INST(ID, PARENT)
///
///   A concrete subclass of SILInstruction.  ID is a member of
///   SILInstructionKind.
#ifndef INST
#define INST(ID, PARENT) NODE(ID, PARENT)
#endif

/// FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
///
///   A macro which includes a bunch of secondary information about
///   an instruction.  In addition to the information from INST:
///
///   NAME is the name of the instruction in SIL assembly.
///   The argument will be a bare identifier, not a string literal.
///
///   MEMBEHAVIOR is an enum value that reflects the memory behavior of
///   the instruction.
///
///   MAYRELEASE indicates whether the execution of the
///   instruction may result in memory being released.
#ifndef FULL_INST
#define FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) INST(ID, PARENT)
#endif

/// NON_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
///
///   ID is a SILInstructionKind and the name of a subclass of SILInstruction
///   that does not inherit from ValueBase.
#ifndef NON_VALUE_INST
#define NON_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
  FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
#endif

/// TERMINATOR(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
///
///   ID is a member of TerminatorKind and the name of a subclass of TermInst.
#ifndef TERMINATOR
#define TERMINATOR(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
  NON_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
#endif

/// ABSTRACT_NODE(ID, PARENT)
///
///   An abstract class in the SILNode hierarchy.   It does not have an
///   enumerator in SILNodeKind and is never the most-derived type of a
///   node.  ID is the name of the class.
///
///   PARENT is the name of its abstract superclass in the node
///   hierarchy, which will be either a subject of an ABSTRACT_NODE
///   entry or SILNode.  SingleValueInstruction considers its superclass
///   to be SILInstruction for the purposes of the node hierarchy.
#ifndef ABSTRACT_NODE
#define ABSTRACT_NODE(ID, PARENT)
#endif

// Handle SingleValueInstruction.
#ifdef ABSTRACT_VALUE
#define ABSTRACT_VALUE_AND_INST(ID, VALUE_PARENT, INST_PARENT) \
  ABSTRACT_VALUE(ID, VALUE_PARENT)
#else
#define ABSTRACT_VALUE_AND_INST(ID, VALUE_PARENT, INST_PARENT) \
  ABSTRACT_INST(ID, INST_PARENT)
#endif

/// ABSTRACT_SINGLE_VALUE_INST(ID, PARENT)
///
///   An abstract subclass of SingleValueInstruction, which is therefore
///   in both the ValueBase and SILInstruction hierarchies.
#ifndef ABSTRACT_SINGLE_VALUE_INST
#ifdef ABSTRACT_VALUE
#define ABSTRACT_SINGLE_VALUE_INST(ID, PARENT) ABSTRACT_VALUE(ID, PARENT)
#else
#define ABSTRACT_SINGLE_VALUE_INST(ID, PARENT) ABSTRACT_INST(ID, PARENT)
#endif
#endif

/// ABSTRACT_VALUE(ID, PARENT)
///
///   An abstract class in the ValueBase hierarchy.   It does not have an
///   enumerator in ValueKind and is never the most-derived type of a
///   node.  ID is the name of the class.
///
///   PARENT is the name of its abstract superclass in the ValueBase
///   hierarchy, which be either a subject of an ABSTRACT_VALUE
///   entry or ValueBase.
#ifndef ABSTRACT_VALUE
#define ABSTRACT_VALUE(ID, PARENT) ABSTRACT_NODE(ID, PARENT)
#endif

/// ABSTRACT_INST(ID, PARENT)
///
///   An abstract class in the SILInstruction hierarchy.   It does not
///   enumerator in SILInstructionKind and is never the most-derived type
///   of a node.  ID is the name of the class.
///
///   PARENT is the name of its abstract superclass in the SILInstruction
///   hierarchy, which be either a subject of an ABSTRACT_INST
///   entry or SILInstruction.
#ifndef ABSTRACT_INST
#define ABSTRACT_INST(ID, PARENT) ABSTRACT_NODE(ID, PARENT)
#endif

/// NODE_RANGE(ID, PARENT)
///
///   The enumerator range of an abstract class in the SILNode hierarchy.
///   This will always appear right after the last member of the class.
#ifndef NODE_RANGE
#define NODE_RANGE(ID, FIRST, LAST)
#endif

#ifndef SINGLE_VALUE_INST_RANGE
#ifdef VALUE_RANGE
#define SINGLE_VALUE_INST_RANGE(ID, FIRST, LAST) VALUE_RANGE(ID, FIRST, LAST)
#else
#define SINGLE_VALUE_INST_RANGE(ID, FIRST, LAST) INST_RANGE(ID, FIRST, LAST)
#endif
#endif

/// VALUE_RANGE(ID, PARENT)
///
///   The enumerator range of an abstract class in the ValueBase hierarchy.
#ifndef VALUE_RANGE
#define VALUE_RANGE(ID, FIRST, LAST) NODE_RANGE(ID, FIRST, LAST)
#endif

/// INST_RANGE(ID, PARENT)
///
///   The enumerator range of an abstract class in the SILInstruction
///   hierarchy.
#ifndef INST_RANGE
#define INST_RANGE(ID, FIRST, LAST) NODE_RANGE(ID, FIRST, LAST)
#endif

ABSTRACT_NODE(ValueBase, SILNode)

ABSTRACT_VALUE(SILArgument, ValueBase)
  ARGUMENT(SILPHIArgument, SILArgument)
  ARGUMENT(SILFunctionArgument, SILArgument)
  VALUE_RANGE(SILArgument, SILPHIArgument, SILFunctionArgument)

ABSTRACT_VALUE(MultipleValueInstructionResult, ValueBase)
  MULTIPLE_VALUE_INST_RESULT(BeginApplyResult, MultipleValueInstructionResult)
  MULTIPLE_VALUE_INST_RESULT(DestructureStructResult, MultipleValueInstructionResult)
  MULTIPLE_VALUE_INST_RESULT(DestructureTupleResult, MultipleValueInstructionResult)
  VALUE_RANGE(MultipleValueInstructionResult, BeginApplyResult, DestructureTupleResult)

VALUE(SILUndef, ValueBase)

ABSTRACT_NODE(SILInstruction, SILNode)

ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
  // Allocation instructions.
  ABSTRACT_SINGLE_VALUE_INST(AllocationInst, SingleValueInstruction)
    SINGLE_VALUE_INST(AllocStackInst, alloc_stack,
                      AllocationInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AllocRefInst, alloc_ref,
                      AllocationInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AllocRefDynamicInst, alloc_ref_dynamic,
                      AllocationInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AllocValueBufferInst, alloc_value_buffer,
                      AllocationInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AllocBoxInst, alloc_box,
                      AllocationInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AllocExistentialBoxInst, alloc_existential_box,
                      AllocationInst, MayWrite, DoesNotRelease)
    SINGLE_VALUE_INST_RANGE(AllocationInst, AllocStackInst, AllocExistentialBoxInst)

  ABSTRACT_SINGLE_VALUE_INST(IndexingInst, SingleValueInstruction)
    SINGLE_VALUE_INST(IndexAddrInst, index_addr,
                      IndexingInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(TailAddrInst, tail_addr,
                      IndexingInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(IndexRawPointerInst, index_raw_pointer,
                      IndexingInst, None, DoesNotRelease)
    SINGLE_VALUE_INST_RANGE(IndexingInst, IndexAddrInst, IndexRawPointerInst)

  // Literals
  ABSTRACT_SINGLE_VALUE_INST(LiteralInst, SingleValueInstruction)
    SINGLE_VALUE_INST(FunctionRefInst, function_ref,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(GlobalAddrInst, global_addr,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(GlobalValueInst, global_value,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(IntegerLiteralInst, integer_literal,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(FloatLiteralInst, float_literal,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(StringLiteralInst, string_literal,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ConstStringLiteralInst, const_string_literal,
                      LiteralInst, None, DoesNotRelease)
    SINGLE_VALUE_INST_RANGE(LiteralInst, FunctionRefInst, ConstStringLiteralInst)

  // Dynamic Dispatch
  ABSTRACT_SINGLE_VALUE_INST(MethodInst, SingleValueInstruction)
    SINGLE_VALUE_INST(ClassMethodInst, class_method,
                      MethodInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(SuperMethodInst, super_method,
                      MethodInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ObjCMethodInst, objc_method,
                      MethodInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ObjCSuperMethodInst, objc_super_method,
                      MethodInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(WitnessMethodInst, witness_method,
                      MethodInst, None, DoesNotRelease)
    SINGLE_VALUE_INST_RANGE(MethodInst, ClassMethodInst, WitnessMethodInst)

  // Conversions
  ABSTRACT_SINGLE_VALUE_INST(ConversionInst, SingleValueInstruction)
    SINGLE_VALUE_INST(UpcastInst, upcast,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(AddressToPointerInst, address_to_pointer,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(PointerToAddressInst, pointer_to_address,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UncheckedRefCastInst, unchecked_ref_cast,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UncheckedAddrCastInst, unchecked_addr_cast,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UncheckedTrivialBitCastInst, unchecked_trivial_bit_cast,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UncheckedBitwiseCastInst, unchecked_bitwise_cast,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(RefToRawPointerInst, ref_to_raw_pointer,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(RawPointerToRefInst, raw_pointer_to_ref,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(RefToUnownedInst, ref_to_unowned,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UnownedToRefInst, unowned_to_ref,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(RefToUnmanagedInst, ref_to_unmanaged,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(UnmanagedToRefInst, unmanaged_to_ref,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ConvertFunctionInst, convert_function,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ThinFunctionToPointerInst, thin_function_to_pointer,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(PointerToThinFunctionInst, pointer_to_thin_function,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(BridgeObjectToWordInst, bridge_object_to_word,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ThinToThickFunctionInst, thin_to_thick_function,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ThickToObjCMetatypeInst, thick_to_objc_metatype,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ObjCToThickMetatypeInst, objc_to_thick_metatype,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ObjCMetatypeToObjectInst, objc_metatype_to_object,
                      ConversionInst, None, DoesNotRelease)
    SINGLE_VALUE_INST(ObjCExistentialMetatypeToObjectInst, objc_existential_metatype_to_object,
                      ConversionInst, None, DoesNotRelease)
    // unconditional_checked_cast_value reads the source value and produces
    // a new value with a potentially different representation.
    SINGLE_VALUE_INST(UnconditionalCheckedCastValueInst, unconditional_checked_cast_value,
                      ConversionInst, MayRead, MayRelease)
    // unconditional_checked_cast_inst is only MayRead to prevent a subsequent
    // release of the cast's source from being hoisted above the cast:
    // retain X
    // Y = unconditional_checked_cast_inst X
    // _ = Y
    // release X // This release cannot be reordered with the cast.
    //
    // With Semantic SIL, this pattern of unbalanced retain/release
    // should never happen.  Since unconditional_checked_cast is a
    // scalar cast that doesn't affect the value's representation, its
    // side effect can then be modeled as None.
    SINGLE_VALUE_INST(UnconditionalCheckedCastInst, unconditional_checked_cast,
                      ConversionInst, MayRead, DoesNotRelease)
    SINGLE_VALUE_INST_RANGE(ConversionInst, UpcastInst, UnconditionalCheckedCastInst)

  SINGLE_VALUE_INST(MarkDependenceInst, mark_dependence,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(CopyBlockInst, copy_block,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(CopyValueInst, copy_value,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(CopyUnownedValueInst, copy_unowned_value,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(UncheckedOwnershipConversionInst, unchecked_ownership_conversion,
                    SingleValueInstruction, MayHaveSideEffects, MayRelease)
  SINGLE_VALUE_INST(StrongPinInst, strong_pin,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)

  // IsUnique does not actually write to memory but should be modeled
  // as such. Its operand is a pointer to an object reference. The
  // optimizer should not assume that the same object is pointed to after
  // the isUnique instruction. It appears to write a new object reference.
  SINGLE_VALUE_INST(IsUniqueInst, is_unique,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(IsUniqueOrPinnedInst, is_unique_or_pinned,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)

  // Accessing memory
  SINGLE_VALUE_INST(LoadInst, load,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(LoadBorrowInst, load_borrow,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(BeginBorrowInst, begin_borrow,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(StoreBorrowInst, store_borrow,
                    SILInstruction, MayWrite, DoesNotRelease)
  SINGLE_VALUE_INST(BeginAccessInst, begin_access,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  SINGLE_VALUE_INST(LoadUnownedInst, load_unowned,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(LoadWeakInst, load_weak,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(MarkUninitializedInst, mark_uninitialized,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(MarkUninitializedBehaviorInst, mark_uninitialized_behavior,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(ProjectValueBufferInst, project_value_buffer,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(ProjectBoxInst, project_box,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(ProjectExistentialBoxInst, project_existential_box,
                    SingleValueInstruction, None, DoesNotRelease)

  // Function Application
  SINGLE_VALUE_INST(ApplyInst, apply,
                    SingleValueInstruction, MayHaveSideEffects, MayRelease)
  SINGLE_VALUE_INST(BuiltinInst, builtin,
                    SingleValueInstruction, MayHaveSideEffects, MayRelease)
  SINGLE_VALUE_INST(PartialApplyInst, partial_apply,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
  
  // Metatypes
  SINGLE_VALUE_INST(MetatypeInst, metatype,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(ValueMetatypeInst, value_metatype,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(ExistentialMetatypeInst, existential_metatype,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(ObjCProtocolInst, objc_protocol,
                    SingleValueInstruction, None, DoesNotRelease)

  // Aggregate Types
  SINGLE_VALUE_INST(ObjectInst, object,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(TupleInst, tuple,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(TupleExtractInst, tuple_extract,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(TupleElementAddrInst, tuple_element_addr,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(StructInst, struct,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(StructExtractInst, struct_extract,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(StructElementAddrInst, struct_element_addr,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(RefElementAddrInst, ref_element_addr,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(RefTailAddrInst, ref_tail_addr,
                    SingleValueInstruction, None, DoesNotRelease)

  // Enums
  SINGLE_VALUE_INST(EnumInst, enum,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(UncheckedEnumDataInst, unchecked_enum_data,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(InitEnumDataAddrInst, init_enum_data_addr,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(UncheckedTakeEnumDataAddrInst, unchecked_take_enum_data_addr,
                    SingleValueInstruction, MayWrite, DoesNotRelease)
  SINGLE_VALUE_INST(SelectEnumInst, select_enum,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(SelectEnumAddrInst, select_enum_addr,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(SelectValueInst, select_value,
                    SingleValueInstruction, None, DoesNotRelease)

  // Protocol and Protocol Composition Types
  SINGLE_VALUE_INST(InitExistentialAddrInst, init_existential_addr,
                    SingleValueInstruction, MayWrite, DoesNotRelease)
  SINGLE_VALUE_INST(InitExistentialValueInst, init_existential_value,
                    SingleValueInstruction, MayWrite, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialAddrInst, open_existential_addr,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(InitExistentialRefInst, init_existential_ref,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialRefInst, open_existential_ref,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(InitExistentialMetatypeInst, init_existential_metatype,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialMetatypeInst, open_existential_metatype,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialBoxInst, open_existential_box,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialValueInst, open_existential_value,
                    SingleValueInstruction, MayRead, DoesNotRelease)
  SINGLE_VALUE_INST(OpenExistentialBoxValueInst, open_existential_box_value,
                    SingleValueInstruction, MayRead, DoesNotRelease)

  // Blocks
  SINGLE_VALUE_INST(ProjectBlockStorageInst, project_block_storage,
                    SingleValueInstruction, None, DoesNotRelease)
  SINGLE_VALUE_INST(InitBlockStorageHeaderInst, init_block_storage_header,
                    SingleValueInstruction, None, DoesNotRelease)

  // Key paths
  // TODO: The only "side effect" is potentially retaining the returned key path
  // object; is there a more specific effect?
  SINGLE_VALUE_INST(KeyPathInst, keypath,
                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)

  SINGLE_VALUE_INST_RANGE(SingleValueInstruction, AllocStackInst, KeyPathInst)

NODE_RANGE(ValueBase, SILPHIArgument, KeyPathInst)

// Terminators
ABSTRACT_INST(TermInst, SILInstruction)
  TERMINATOR(UnreachableInst, unreachable,
             TermInst, None, DoesNotRelease)
  TERMINATOR(ReturnInst, return,
             TermInst, None, DoesNotRelease)
  TERMINATOR(ThrowInst, throw,
             TermInst, None, DoesNotRelease)
  TERMINATOR(YieldInst, yield,
             TermInst, MayHaveSideEffects, MayRelease)
  TERMINATOR(UnwindInst, unwind,
             TermInst, None, DoesNotRelease)
  TERMINATOR(TryApplyInst, try_apply,
             TermInst, MayHaveSideEffects, MayRelease)
  TERMINATOR(BranchInst, br,
             TermInst, None, DoesNotRelease)
  TERMINATOR(CondBranchInst, cond_br,
             TermInst, None, DoesNotRelease)
  TERMINATOR(SwitchValueInst, switch_value,
             TermInst, None, DoesNotRelease)
  TERMINATOR(SwitchEnumInst, switch_enum,
             TermInst, None, DoesNotRelease)
  TERMINATOR(SwitchEnumAddrInst, switch_enum_addr,
             TermInst, MayRead, DoesNotRelease)
  TERMINATOR(DynamicMethodBranchInst, dynamic_method_br,
             TermInst, None, DoesNotRelease)
  TERMINATOR(CheckedCastBranchInst, checked_cast_br,
             TermInst, None, DoesNotRelease)
  TERMINATOR(CheckedCastAddrBranchInst, checked_cast_addr_br,
             TermInst, MayHaveSideEffects, MayRelease)
  TERMINATOR(CheckedCastValueBranchInst, checked_cast_value_br,
             TermInst, None, DoesNotRelease)
  INST_RANGE(TermInst, UnreachableInst, CheckedCastValueBranchInst)

// Deallocation instructions.
ABSTRACT_INST(DeallocationInst, SILInstruction)
  NON_VALUE_INST(DeallocStackInst, dealloc_stack,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(DeallocRefInst, dealloc_ref,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(DeallocPartialRefInst, dealloc_partial_ref,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(DeallocValueBufferInst, dealloc_value_buffer,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(DeallocBoxInst, dealloc_box,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(DeallocExistentialBoxInst, dealloc_existential_box,
                 DeallocationInst, MayHaveSideEffects, DoesNotRelease)
  INST_RANGE(DeallocationInst, DeallocStackInst, DeallocExistentialBoxInst)

// Reference Counting
ABSTRACT_INST(RefCountingInst, SILInstruction)
  NON_VALUE_INST(StrongRetainInst, strong_retain,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(StrongReleaseInst, strong_release,
                 RefCountingInst, MayHaveSideEffects, MayRelease)
  NON_VALUE_INST(StrongRetainUnownedInst, strong_retain_unowned,
                 RefCountingInst, MayHaveSideEffects,
       DoesNotRelease)
  NON_VALUE_INST(StrongUnpinInst, strong_unpin,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(UnownedRetainInst, unowned_retain,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(UnownedReleaseInst, unowned_release,
                 RefCountingInst, MayHaveSideEffects,
       MayRelease)
  NON_VALUE_INST(UnmanagedRetainValueInst, unmanaged_retain_value,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(UnmanagedReleaseValueInst, unmanaged_release_value,
                 RefCountingInst, MayHaveSideEffects, MayRelease)
  NON_VALUE_INST(UnmanagedAutoreleaseValueInst, unmanaged_autorelease_value,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(RetainValueInst, retain_value,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(RetainValueAddrInst, retain_value_addr,
                 RefCountingInst, MayHaveSideEffects, DoesNotRelease)
  NON_VALUE_INST(ReleaseValueInst, release_value,
                 RefCountingInst, MayHaveSideEffects, MayRelease)
  NON_VALUE_INST(ReleaseValueAddrInst, release_value_addr,
                 RefCountingInst, MayHaveSideEffects, MayRelease)
  NON_VALUE_INST(SetDeallocatingInst, set_deallocating,
                 RefCountingInst, MayHaveSideEffects,
       DoesNotRelease)
  NON_VALUE_INST(AutoreleaseValueInst, autorelease_value,
                 RefCountingInst, MayHaveSideEffects,
       DoesNotRelease)
  INST_RANGE(RefCountingInst, StrongRetainInst, AutoreleaseValueInst)

// BindMemory has no physical side effect. Semantically it writes to
// its affected memory region because any reads or writes accessing
// that memory must be dependent on the bind operation.
NON_VALUE_INST(BindMemoryInst, bind_memory,
               SILInstruction, MayWrite, DoesNotRelease)

// FIXME: Is MayHaveSideEffects appropriate?
NON_VALUE_INST(FixLifetimeInst, fix_lifetime,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)

NON_VALUE_INST(DestroyValueInst, destroy_value,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(EndBorrowInst, end_borrow,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(EndBorrowArgumentInst, end_borrow_argument,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(EndAccessInst, end_access,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(BeginUnpairedAccessInst, begin_unpaired_access,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(EndUnpairedAccessInst, end_unpaired_access,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(StoreInst, store,
               SILInstruction, MayWrite, DoesNotRelease)
NON_VALUE_INST(AssignInst, assign,
               SILInstruction, MayWrite, DoesNotRelease)
NON_VALUE_INST(MarkFunctionEscapeInst, mark_function_escape,
               SILInstruction, None, DoesNotRelease)
NON_VALUE_INST(DebugValueInst, debug_value,
               SILInstruction, None, DoesNotRelease)
NON_VALUE_INST(DebugValueAddrInst, debug_value_addr,
               SILInstruction, None, DoesNotRelease)
NON_VALUE_INST(StoreUnownedInst, store_unowned,
               SILInstruction, MayWrite, DoesNotRelease)
NON_VALUE_INST(StoreWeakInst, store_weak,
               SILInstruction, MayWrite, DoesNotRelease)
NON_VALUE_INST(CopyAddrInst, copy_addr,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(DestroyAddrInst, destroy_addr,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(EndLifetimeInst, end_lifetime,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(InjectEnumAddrInst, inject_enum_addr,
               SILInstruction, MayWrite, DoesNotRelease)
NON_VALUE_INST(DeinitExistentialAddrInst, deinit_existential_addr,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(DeinitExistentialValueInst, deinit_existential_value,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(UnconditionalCheckedCastAddrInst, unconditional_checked_cast_addr,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(UncheckedRefCastAddrInst, unchecked_ref_cast_addr,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(AllocGlobalInst, alloc_global,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)
NON_VALUE_INST(EndApplyInst, end_apply,
               SILInstruction, MayHaveSideEffects, MayRelease)
NON_VALUE_INST(AbortApplyInst, abort_apply,
               SILInstruction, MayHaveSideEffects, MayRelease)

// Runtime failure
// FIXME: Special MemBehavior for runtime failure?
NON_VALUE_INST(CondFailInst, cond_fail,
               SILInstruction, MayHaveSideEffects, DoesNotRelease)

NODE_RANGE(NonValueInstruction, UnreachableInst, CondFailInst)

ABSTRACT_INST(MultipleValueInstruction, SILInstruction)
MULTIPLE_VALUE_INST(BeginApplyInst, begin_apply,
                    SILInstruction, MayHaveSideEffects, MayRelease)
MULTIPLE_VALUE_INST(DestructureStructInst, destructure_struct,
                    SILInstruction, None, DoesNotRelease)
MULTIPLE_VALUE_INST(DestructureTupleInst, destructure_tuple,
                    SILInstruction, None, DoesNotRelease)
INST_RANGE(MultipleValueInstruction, BeginApplyInst, DestructureTupleInst)

NODE_RANGE(SILInstruction, AllocStackInst, DestructureTupleInst)
NODE_RANGE(SILNode, SILPHIArgument, DestructureTupleInst)

#undef SINGLE_VALUE_INST_RANGE
#undef INST_RANGE
#undef VALUE_RANGE
#undef NODE_RANGE
#undef ABSTRACT_SINGLE_VALUE_INST
#undef ABSTRACT_INST
#undef ABSTRACT_VALUE
#undef ABSTRACT_NODE
#undef ABSTRACT_VALUE_AND_INST
#undef TERMINATOR
#undef NON_VALUE_INST
#undef MULTIPLE_VALUE_INST_RESULT
#undef MULTIPLE_VALUE_INST
#undef SINGLE_VALUE_INST
#undef FULL_INST
#undef INST
#undef ARGUMENT
#undef VALUE
#undef NODE
