averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
bc76ac0f5045cc470202c3ac9400b67a1fc901b8
swift-mirror/include/swift/SIL/SILNodes.def
John McCall 045998544f Add begin_apply, abort_apply, and end_apply instructions to allow 
yield_once coroutines to be executed.
2017-11-13 04:03:54 -05:00

679 lines
31 KiB
C++
Raw Blame History

//===--- 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
Reference in New Issue View Git Blame Copy Permalink