A dump of the entire SILOptimizer and all its dependencies.

The SILOptimizer as Swift sees it.swift

import std_config

var SWIFT_LLVM_ODR_SAFE: Int32 { get }
extension swift {
  typealias SmallBitVector = llvm.SmallBitVector
  typealias StringLiteral = llvm.StringLiteral
  typealias StringRef = llvm.StringRef
  typealias Twine = llvm.Twine
  typealias APFloat = llvm.APFloat
  typealias APInt = llvm.APInt
  typealias NoneType = llvm.NoneType
  typealias raw_ostream = llvm.raw_ostream

  /// A class for computing basic dominance information.
  struct DominanceInfo {
    init(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Does instruction A properly dominate instruction B?
    mutating func properlyDominates(_ a: UnsafeMutablePointer<swift.SILInstruction>!, _ b: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

    /// Does instruction A dominate instruction B?
    mutating func dominates(_ a: UnsafeMutablePointer<swift.SILInstruction>!, _ b: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

    /// Does value A properly dominate instruction B?
    mutating func properlyDominates(_ a: swift.SILValue, _ b: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool
    mutating func verify()

    /// Return true if the other dominator tree does not match this dominator
    /// tree.
    mutating func errorOccurredOnComparison(_ Other: UnsafePointer<swift.DominanceInfo>) -> Bool
    mutating func isValid(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> Bool
    mutating func reset()
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE {
    init(_ P: UnsafeMutablePointer<swift.SourceFile>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.SourceFile>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.SourceFile>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.SourceFile>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.SourceFile>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.SourceFile>!) -> UnsafeMutablePointer<swift.SourceFile>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.SourceFile>!) -> UnsafePointer<swift.SourceFile>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE, other: UnsafePointer<swift.SourceFile>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_10SourceFileEEE, other: UnsafePointer<swift.SourceFile>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE {
    init(_ P: OpaquePointer!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> OpaquePointer!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> OpaquePointer!
    mutating func getPtrOrNull() -> OpaquePointer!
    mutating func getPtrOrNull() -> OpaquePointer!
    mutating func getPtrOr(_ defaultValue: OpaquePointer!) -> OpaquePointer!
    mutating func getPtrOr(_ defaultValue: OpaquePointer!) -> OpaquePointer!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE, other: OpaquePointer!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_8ASTScopeEEE, other: OpaquePointer!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE {
    init(_ P: UnsafeMutablePointer<swift.PostOrderFunctionInfo>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.PostOrderFunctionInfo>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.PostOrderFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.PostOrderFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.PostOrderFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.PostOrderFunctionInfo>!) -> UnsafeMutablePointer<swift.PostOrderFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.PostOrderFunctionInfo>!) -> UnsafePointer<swift.PostOrderFunctionInfo>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE, other: UnsafePointer<swift.PostOrderFunctionInfo>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_21PostOrderFunctionInfoEEE, other: UnsafePointer<swift.PostOrderFunctionInfo>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE {
    init(_ P: UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.RCIdentityFunctionInfo>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.RCIdentityFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!) -> UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.RCIdentityFunctionInfo>!) -> UnsafePointer<swift.RCIdentityFunctionInfo>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE, other: UnsafePointer<swift.RCIdentityFunctionInfo>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_22RCIdentityFunctionInfoEEE, other: UnsafePointer<swift.RCIdentityFunctionInfo>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE {
    init(_ P: UnsafeMutablePointer<swift.VarDecl>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.VarDecl>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.VarDecl>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.VarDecl>!) -> UnsafePointer<swift.VarDecl>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE, other: UnsafePointer<swift.VarDecl>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE, other: UnsafePointer<swift.VarDecl>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE {
    init(_ P: UnsafeMutablePointer<swift.evaluator.DependencyRecorder>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.evaluator.DependencyRecorder>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.evaluator.DependencyRecorder>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.evaluator.DependencyRecorder>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.evaluator.DependencyRecorder>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.evaluator.DependencyRecorder>!) -> UnsafeMutablePointer<swift.evaluator.DependencyRecorder>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.evaluator.DependencyRecorder>!) -> UnsafePointer<swift.evaluator.DependencyRecorder>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE, other: UnsafePointer<swift.evaluator.DependencyRecorder>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_9evaluator18DependencyRecorderEEE, other: UnsafePointer<swift.evaluator.DependencyRecorder>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE {
    init(_ P: UnsafeMutablePointer<swift.EnumElementDecl>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.EnumElementDecl>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.EnumElementDecl>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.EnumElementDecl>!) -> UnsafePointer<swift.EnumElementDecl>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE, other: UnsafePointer<swift.EnumElementDecl>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE, other: UnsafePointer<swift.EnumElementDecl>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE {
    init(_ P: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.SILBasicBlock>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.SILBasicBlock>!) -> UnsafePointer<swift.SILBasicBlock>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE, other: UnsafePointer<swift.SILBasicBlock>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE, other: UnsafePointer<swift.SILBasicBlock>!) -> Bool
  }

  /// NullablePtr pointer wrapper - NullablePtr is used for APIs where a
  /// potentially-null pointer gets passed around that must be explicitly handled
  /// in lots of places.  By putting a wrapper around the null pointer, it makes
  /// it more likely that the null pointer case will be handled correctly.
  struct __CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE {
    init(_ P: UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!)
    mutating func isNull() -> Bool
    mutating func isNonNull() -> Bool

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafePointer<swift.EpilogueARCFunctionInfo>!

    /// get - Return the pointer if it is non-null.
    mutating func get() -> UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!
    mutating func getPtrOrNull() -> UnsafePointer<swift.EpilogueARCFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!) -> UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!
    mutating func getPtrOr(_ defaultValue: UnsafePointer<swift.EpilogueARCFunctionInfo>!) -> UnsafePointer<swift.EpilogueARCFunctionInfo>!
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE>) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE, other: UnsafePointer<swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE>) -> Bool
    static func == (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE, other: UnsafePointer<swift.EpilogueARCFunctionInfo>!) -> Bool
    static func != (lhs: inout swift.__CxxTemplateInstN5swift11NullablePtrINS_23EpilogueARCFunctionInfoEEE, other: UnsafePointer<swift.EpilogueARCFunctionInfo>!) -> Bool
  }
  typealias DeadInstructionSet = llvm.__CxxTemplateInstN4llvm14SmallSetVectorIPN5swift14SILInstructionELj8EEE

  /// A utility for deleting one or more instructions belonging to a function, and
  /// cleaning up any dead code resulting from deleting those instructions. Use
  /// this utility instead of
  /// \c recursivelyDeleteTriviallyDeadInstruction.
  struct InstructionDeleter {
    init()

    /// If the instruction \p inst is dead, record it so that it can be cleaned
    /// up.
    mutating func trackIfDead(_ inst: UnsafeMutablePointer<swift.SILInstruction>!)

    /// If the instruction \p inst is dead, delete it immediately and record
    /// its operands so that they can be cleaned up later.
    mutating func deleteIfDead(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

    /// Delete the instruction \p inst and record instructions that may become
    /// dead because of the removal of \c inst. This function will add necessary
    /// ownership instructions to fix the lifetimes of the operands of \c inst to
    /// compensate for its deletion. This function will not clean up dead code
    /// resulting from the instruction's removal. To do so, invoke the method \c
    /// cleanupDeadCode of this instance, once the SIL of the contaning function
    /// is made consistent.
    ///
    /// \pre the function containing \c inst must be using ownership SIL.
    /// \pre the instruction to be deleted must not have any use other than
    /// incidental uses.
    ///
    /// \param callback a callback called whenever an instruction
    /// is deleted.
    mutating func forceDeleteAndFixLifetimes(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

    /// Delete the instruction \p inst and record instructions that may become
    /// dead because of the removal of \c inst. If in ownership SIL, use the
    /// \c forceDeleteAndFixLifetimes function instead, unless under special
    /// circumstances where the client must handle fixing lifetimes of the
    /// operands of the deleted instructions. This function will not fix the
    /// lifetimes of the operands of \c inst once it is deleted. This function
    /// will not clean up dead code resulting from the instruction's removal. To
    /// do so, invoke the method \c cleanupDeadCode of this instance, once the SIL
    /// of the contaning function is made consistent.
    ///
    /// \pre the instruction to be deleted must not have any use other than
    /// incidental uses.
    ///
    /// \param callback a callback called whenever an instruction
    /// is deleted.
    mutating func forceDelete(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

    /// Clean up dead instructions that are tracked by this instance and all
    /// instructions that transitively become dead.
    ///
    /// \pre the function contaning dead instructions must be consistent (i.e., no
    /// under or over releases). Note that if \c forceDelete call leaves the
    /// function body in an inconsistent state, it needs to be made consistent
    /// before this method is invoked.
    ///
    /// \param callback a callback called whenever an instruction is deleted.
    mutating func cleanUpDeadInstructions(_ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

    /// Recursively visit users of \c inst  (including \c inst)and delete
    /// instructions that are dead (including \c inst). Invoke the \c callback on
    /// instructions that are deleted.
    mutating func recursivelyDeleteUsersIfDead(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

    /// Recursively visit users of \c inst  (including \c inst)and force delete
    /// them. Also, destroy the consumed operands of the deleted instructions
    /// whenever necessary. Invoke the \c callback on instructions that are
    /// deleted.
    mutating func recursivelyForceDeleteUsersAndFixLifetimes(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)
  }

  /// If \c inst is dead, delete it and recursively eliminate all code that
  /// becomes dead because of that. If more than one instruction must
  /// be checked/deleted use the \c InstructionDeleter utility.
  ///
  /// This function will add necessary compensation code to fix the lifetimes of
  /// the operands of the deleted instructions.
  ///
  /// \pre the SIL function containing the instruction is assumed to be
  /// consistent, i.e., does not have under or over releases.
  ///
  /// \param callback a callback called whenever an instruction is deleted.
  static func eliminateDeadInstruction(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

  /// Return the number of @inout arguments passed to the given apply site.
  static func getNumInOutArguments(_ applySite: swift.FullApplySite) -> UInt32

  /// For each of the given instructions, if they are dead delete them
  /// along with their dead operands. Note this utility must be phased out and
  /// replaced by \c eliminateDeadInstruction  and
  /// \c InstructionDeleter utilities.
  ///
  /// \param inst The ArrayRef of instructions to be deleted.
  /// \param force If Force is set, don't check if the top level instructions
  ///        are considered dead - delete them regardless.
  /// \param callback a callback called whenever an instruction is deleted.
  static func recursivelyDeleteTriviallyDeadInstructions(_ inst: llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift14SILInstructionEEE, _ force: Bool, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

  /// If the given instruction is dead, delete it along with its dead
  /// operands. Note this utility must be phased out and replaced by
  /// \c eliminateDeadInstruction and
  /// \c InstructionDeleter utilities.
  ///
  /// \param inst The instruction to be deleted.
  /// \param force If Force is set, don't check if the top level instruction is
  ///        considered dead - delete it regardless.
  /// \param callback a callback called whenever an instruction is deleted.
  static func recursivelyDeleteTriviallyDeadInstructions(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ force: Bool, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

  /// Perform a fast local check to see if the instruction is dead.
  ///
  /// This routine only examines the state of the instruction at hand.
  static func isInstructionTriviallyDead(_ inst: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// Return true if this is a release instruction that's not going to
  /// free the object.
  static func isIntermediateRelease(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ erfi: UnsafeMutablePointer<swift.EpilogueARCFunctionInfo>!) -> Bool

  /// Recursively erase all of the uses of the instruction (but not the
  /// instruction itself)
  static func eraseUsesOfInstruction(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ callback: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift14SILInstructionEEEE)

  /// Recursively erase all of the uses of the value (but not the
  /// value itself)
  static func eraseUsesOfValue(_ value: swift.SILValue)

  /// Gets the concrete value which is stored in an existential box.
  /// Returns %value in following pattern:
  ///
  ///    %existentialBox = alloc_existential_box $Error, $ConcreteError
  ///    %a = project_existential_box $ConcreteError in %existentialBox : $Error
  ///    store %value to %a : $*ConcreteError
  ///
  /// Returns an invalid SILValue in case there are multiple stores or any unknown
  /// users of \p existentialBox.
  /// The \p ignoreUser is ignored in the user list of \p existentialBox.
  static func getConcreteValueOfExistentialBox(_ existentialBox: UnsafeMutablePointer<swift.AllocExistentialBoxInst>!, _ ignoreUser: UnsafeMutablePointer<swift.SILInstruction>!) -> swift.SILValue

  /// Gets the concrete value which is stored in an existential box, which itself
  /// is stored in \p addr.
  /// Returns %value in following pattern:
  ///
  ///    %b = alloc_existential_box $Error, $ConcreteError
  ///    %a = project_existential_box $ConcreteError in %b : $Error
  ///    store %value to %a : $*ConcreteError
  ///    %addr = alloc_stack $Error
  ///    store %b to %addr : $*Error
  ///
  /// Returns an invalid SILValue in case there are multiple stores or any unknown
  /// users of \p addr or the existential box.
  /// The \p ignoreUser is ignored in the user list of \p addr.
  static func getConcreteValueOfExistentialBoxAddr(_ addr: swift.SILValue, _ ignoreUser: UnsafeMutablePointer<swift.SILInstruction>!) -> swift.SILValue
  static func findApplyFromDevirtualizedResult(_ value: swift.SILValue) -> swift.FullApplySite

  /// Peek through trivial Enum initialization, typically for pointless
  /// Optionals.
  ///
  /// The returned InitEnumDataAddr dominates the given
  /// UncheckedTakeEnumDataAddrInst.
  static func findInitAddressForTrivialEnum(_ utedai: UnsafeMutablePointer<swift.UncheckedTakeEnumDataAddrInst>!) -> UnsafeMutablePointer<swift.InitEnumDataAddrInst>!

  /// Returns a project_box if it is the next instruction after \p ABI and
  /// and has \p ABI as operand. Otherwise it creates a new project_box right
  /// after \p ABI and returns it.
  static func getOrCreateProjectBox(_ abi: UnsafeMutablePointer<swift.AllocBoxInst>!, _ index: UInt32) -> UnsafeMutablePointer<swift.ProjectBoxInst>!

  /// Return true if any call inside the given function may bind dynamic
  /// 'Self' to a generic argument of the callee.
  static func mayBindDynamicSelf(_ f: UnsafeMutablePointer<swift.SILFunction>!) -> Bool

  /// Check whether the \p addr is an address of a tail-allocated array element.
  static func isAddressOfArrayElement(_ addr: swift.SILValue) -> Bool

  /// Move an ApplyInst's FuncRef so that it dominates the call site.
  static func placeFuncRef(_ ai: UnsafeMutablePointer<swift.ApplyInst>!, _ dt: UnsafeMutablePointer<swift.DominanceInfo>!)

  /// Add an argument, \p val, to the branch-edge that is pointing into
  /// block \p Dest. Return a new instruction and do not erase the old
  /// instruction.
  static func addArgumentToBranch(_ val: swift.SILValue, _ dest: UnsafeMutablePointer<swift.SILBasicBlock>!, _ branch: UnsafeMutablePointer<swift.TermInst>!) -> UnsafeMutablePointer<swift.TermInst>!

  /// Get the linkage to be used for specializations of a function with
  /// the given linkage.
  static func getSpecializedLinkage(_ f: UnsafeMutablePointer<swift.SILFunction>!, _ linkage: swift.SILLinkage) -> swift.SILLinkage

  /// Tries to perform jump-threading on all checked_cast_br instruction in
  /// function \p Fn.
  static func tryCheckedCastBrJumpThreading(_ fn: UnsafeMutablePointer<swift.SILFunction>!, _ dt: UnsafeMutablePointer<swift.DominanceInfo>!, _ blocksForWorklist: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift13SILBasicBlockEEE>) -> Bool

  /// A structure containing callbacks that are called when an instruction is
  /// removed or added.
  struct InstModCallbacks {
    static let defaultDeleteInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE
    static let defaultCreatedNewInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE
    static let defaultReplaceValueUsesWith: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift8SILValueES2_EEE
    static let defaultEraseAndRAUWSingleValueInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift22SingleValueInstructionENS1_8SILValueEEEE
    var deleteInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE
    var createdNewInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE
    var replaceValueUsesWith: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift8SILValueES2_EEE
    var eraseAndRAUWSingleValueInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift22SingleValueInstructionENS1_8SILValueEEEE
    init(_ deleteInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ createdNewInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ replaceValueUsesWith: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift8SILValueES2_EEE)
    init(_ deleteInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ createdNewInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ replaceValueUsesWith: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift8SILValueES2_EEE, _ eraseAndRAUWSingleValueInst: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift22SingleValueInstructionENS1_8SILValueEEEE)
    init()
  }

  /// Emit destroy operation for \p operand, and call appropriate functions from
  /// \p callbacks for newly created instructions and deleted instructions.
  static func emitDestroyOperation(_ builder: UnsafeMutablePointer<swift.SILBuilder>, _ loc: swift.SILLocation, _ operand: swift.SILValue, _ callbacks: swift.InstModCallbacks)

  /// Collect all (transitive) users of \p inst which just copy or destroy \p
  /// inst.
  ///
  /// In other words: all users which do not prevent \p inst from being considered
  /// as "dead".
  /// Returns true, if there are no other users beside those collected in \p
  /// destroys, i.e. if \p inst can be considered as "dead".
  static func collectDestroys(_ inst: UnsafeMutablePointer<swift.SingleValueInstruction>!, _ destroys: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>) -> Bool

  /// If Closure is a partial_apply or thin_to_thick_function with only local
  /// ref count users and a set of post-dominating releases:
  ///
  /// 1. Remove all ref count operations and the closure.
  /// 2. At each one of the last release locations insert releases for the
  ///    captured args if we have a partial_apply (except \p needKeepArgsAlive is
  ///    false).
  ///
  /// In the future this should be extended to be less conservative with users.
  static func tryDeleteDeadClosure(_ closure: UnsafeMutablePointer<swift.SingleValueInstruction>!, _ callbacks: swift.InstModCallbacks, _ needKeepArgsAlive: Bool) -> Bool

  /// Given a SILValue argument to a partial apply \p Arg and the associated
  /// parameter info for that argument, perform the necessary cleanups to Arg when
  /// one is attempting to delete the partial apply.
  static func releasePartialApplyCapturedArg(_ builder: UnsafeMutablePointer<swift.SILBuilder>, _ loc: swift.SILLocation, _ arg: swift.SILValue, _ paramInfo: swift.SILParameterInfo, _ callbacks: swift.InstModCallbacks)
  static func deallocPartialApplyCapturedArg(_ builder: UnsafeMutablePointer<swift.SILBuilder>, _ loc: swift.SILLocation, _ arg: swift.SILValue, _ paramInfo: swift.SILParameterInfo)

  /// Insert destroys of captured arguments of partial_apply [stack].
  static func insertDestroyOfCapturedArguments(_ pai: UnsafeMutablePointer<swift.PartialApplyInst>!, _ builder: UnsafeMutablePointer<swift.SILBuilder>, _ shouldInsertDestroy: llvm.__CxxTemplateInstN4llvm12function_refIFbN5swift8SILValueEEEE)
  static func insertDeallocOfCapturedArguments(_ pai: UnsafeMutablePointer<swift.PartialApplyInst>!, _ builder: UnsafeMutablePointer<swift.SILBuilder>)

  /// This iterator 'looks through' one level of builtin expect users exposing all
  /// users of the looked through builtin expect instruction i.e it presents a
  /// view that shows all users as if there were no builtin expect instructions
  /// interposed.
  struct IgnoreExpectUseIterator {
    init(_ value: UnsafeMutablePointer<swift.ValueBase>!)
    init()
    static func * (lhs: inout swift.IgnoreExpectUseIterator) -> UnsafeMutablePointer<swift.Operand>!
    mutating func getUser() -> UnsafeMutablePointer<swift.SILInstruction>!
  }
  static func ignore_expect_uses(_ value: UnsafeMutablePointer<swift.ValueBase>!) -> llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift23IgnoreExpectUseIteratorEEE

  /// Run simplifyInstruction() on all of the instruction I's users if they only
  /// have one result (since simplifyInstruction assumes that). Replace all uses
  /// of the user with its simplification of we succeed. Returns true if we
  /// succeed and false otherwise.
  ///
  /// An example of how this is useful is in cases where one is splitting up an
  /// aggregate and reforming it, the reformed aggregate may have extract
  /// operations from it. These can be simplified and removed.
  static func simplifyUsers(_ inst: UnsafeMutablePointer<swift.SingleValueInstruction>!) -> Bool

  ///  True if a type can be expanded
  /// without a significant increase to code size.
  static func shouldExpand(_ module: UnsafeMutablePointer<swift.SILModule>, _ ty: swift.SILType) -> Bool

  /// Check if the value of value is computed by means of a simple initialization.
  /// Store the actual SILValue into \p Val and the reversed list of instructions
  /// initializing it in \p Insns.
  /// The check is performed by recursively walking the computation of the
  /// SIL value being analyzed.
  static func analyzeStaticInitializer(_ value: swift.SILValue, _ insns: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>) -> Bool

  /// Returns true if the below operation will succeed.
  static func canReplaceLoadSequence(_ inst: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// Replace load sequence which may contain
  /// a chain of struct_element_addr followed by a load.
  /// The sequence is traversed inside out, i.e.
  /// starting with the innermost struct_element_addr
  static func replaceLoadSequence(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ value: swift.SILValue)

  /// Do we have enough information to determine all callees that could
  /// be reached by calling the function represented by Decl?
  static func calleesAreStaticallyKnowable(_ module: UnsafeMutablePointer<swift.SILModule>, _ decl: swift.SILDeclRef) -> Bool

  /// Do we have enough information to determine all callees that could
  /// be reached by calling the function represented by Decl?
  static func calleesAreStaticallyKnowable(_ module: UnsafeMutablePointer<swift.SILModule>, _ vd: UnsafeMutablePointer<swift.ValueDecl>!) -> Bool
  static func getInstanceWithExactDynamicType(_ instance: swift.SILValue, _ cha: UnsafeMutablePointer<swift.ClassHierarchyAnalysis>!) -> swift.SILValue

  /// Try to determine the exact dynamic type of an object.
  /// returns the exact dynamic type of the object, or an empty type if the exact
  /// type could not be determined.
  static func getExactDynamicType(_ instance: swift.SILValue, _ cha: UnsafeMutablePointer<swift.ClassHierarchyAnalysis>!, _ forUnderlyingObject: Bool) -> swift.SILType

  /// Try to statically determine the exact dynamic type of the underlying object.
  /// returns the exact dynamic type of the underlying object, or an empty SILType
  /// if the exact type could not be determined.
  static func getExactDynamicTypeOfUnderlyingObject(_ instance: swift.SILValue, _ cha: UnsafeMutablePointer<swift.ClassHierarchyAnalysis>!) -> swift.SILType

  ///
  /// NOTE: Generally it is not suggested to have move only types that contain
  /// small vectors. Since our small vectors contain one element or a std::vector
  /// like data structure , this is ok since we will either just copy the single
  /// element when we do the move or perform a move of the vector type.
  struct FindLocalApplySitesResult {

    /// Contains the list of local non fully applied partial apply sites that we
    /// found.
    var partialApplySites: llvm.__CxxTemplateInstN4llvm11SmallVectorIN5swift9ApplySiteELj1EEE

    /// Contains the list of full apply sites that we found.
    var fullApplySites: llvm.__CxxTemplateInstN4llvm11SmallVectorIN5swift13FullApplySiteELj1EEE

    /// Set to true if the function_ref escapes into a use that our analysis does
    /// not understand. Set to false if we found a use that had an actual
    /// escape. Set to None if we did not find any call sites, but also didn't
    /// find any "escaping uses" as well.
    ///
    /// The none case is so that we can distinguish in between saying that a value
    /// did escape and saying that we did not find any conservative information.
    var escapes: Bool
    init()
    init(partialApplySites: llvm.__CxxTemplateInstN4llvm11SmallVectorIN5swift9ApplySiteELj1EEE, fullApplySites: llvm.__CxxTemplateInstN4llvm11SmallVectorIN5swift13FullApplySiteELj1EEE, escapes: Bool)

    /// Treat this function ref as escaping only if we found an actual user we
    /// didn't understand. Do not treat it as escaping if we did not find any
    /// users at all.
    mutating func isEscaping() -> Bool
  }

  /// Gets the base implementation of a method.
  static func getBaseMethod(_ FD: UnsafeMutablePointer<swift.AbstractFunctionDecl>!) -> UnsafeMutablePointer<swift.AbstractFunctionDecl>!
  static func tryOptimizeApplyOfPartialApply(_ pai: UnsafeMutablePointer<swift.PartialApplyInst>!, _ builderCtxt: UnsafeMutablePointer<swift.SILBuilderContext>, _ callbacks: swift.InstModCallbacks) -> Bool

  /// Clone this full apply site, replacing the callee with \p newCallee while
  /// doing so.
  ///
  /// The current full apply site is used as an insertion point, so the caller
  /// must clean up this full apply site.
  static func cloneFullApplySiteReplacingCallee(_ applySite: swift.FullApplySite, _ newCallee: swift.SILValue, _ builderCtx: UnsafeMutablePointer<swift.SILBuilderContext>) -> swift.FullApplySite
  struct Bar {
    init()
  }

  /// This is the root class for all instructions that can be used as the
  /// contents of a Swift SILBasicBlock.
  ///
  /// Most instructions are defined in terms of two basic kinds of
  /// structure: a list of operand values upon which the instruction depends
  /// and a list of result values upon which other instructions can depend.
  ///
  /// The operands can be divided into two sets:
  ///   - the formal operands of the instruction, which reflect its
  ///     direct value dependencies, and
  ///   - the type-dependent operands, which reflect dependencies that are
  ///     not captured by the formal operands; currently, these dependencies
  ///     only arise due to certain instructions (e.g. open_existential_addr)
  ///     that bind new archetypes in the local context.
  struct SILInstruction {
    enum MemoryBehavior : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case None

      /// The instruction may read memory.
      case MayRead

      /// The instruction may write to memory.
      /// This includes destroying or taking from memory (e.g. destroy_addr,
      /// copy_addr [take], load [take]).
      /// Although, physically, destroying or taking does not modify the memory,
      /// it is important to model it is a write. Optimizations must not assume
      /// that the value stored in memory is still available for loading after
      /// the memory is destroyed or taken.
      case MayWrite

      /// The instruction may read or write memory.
      case MayReadWrite

      /// The instruction may have side effects not captured
      ///        solely by its users. Specifically, it can return,
      ///        release memory, or store. Note, alloc is not considered
      ///        to have side effects because its result/users represent
      ///        its effect.
      case MayHaveSideEffects
    }

    /// Enumeration representing whether the execution of an instruction can
    /// result in memory being released.
    enum ReleasingBehavior : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case DoesNotRelease
      case MayRelease
    }
    typealias OperandValueRange = swift.__CxxTemplateInstN5swift22OptionalTransformRangeIN4llvm8ArrayRefINS_7OperandEEENS_14SILInstruction14OperandToValueEPKS3_EE
    typealias OperandTypeRange = swift.__CxxTemplateInstN5swift22OptionalTransformRangeIN4llvm8ArrayRefINS_7OperandEEENS_14SILInstruction13OperandToTypeEPKS3_EE
    mutating func getKind() -> swift.SILInstructionKind
    mutating func getParent() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getParent() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getFunction() -> UnsafePointer<swift.SILFunction>!

    /// Is this instruction part of a static initializer of a SILGlobalVariable?
    mutating func isStaticInitializerInst() -> Bool
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>

    /// This instruction's source location (AST node).
    mutating func getLoc() -> swift.SILLocation
    mutating func getDebugScope() -> UnsafePointer<swift.SILDebugScope>!
    mutating func getDebugLocation() -> swift.SILDebugLocation

    /// Sets the debug location.
    /// Note: Usually it should not be needed to use this function as the location
    /// is already set in when creating an instruction.
    mutating func setDebugLocation(_ Loc: swift.SILDebugLocation)

    /// This method unlinks 'self' from the containing basic block and deletes it.
    mutating func eraseFromParent()

    /// Unlink this instruction from its current basic block and insert the
    /// instruction such that it is the first instruction of \p Block.
    mutating func moveFront(_ Block: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Unlink this instruction from its current basic block and insert it into
    /// the basic block that Later lives in, right before Later.
    mutating func moveBefore(_ Later: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Unlink this instruction from its current basic block and insert it into
    /// the basic block that Earlier lives in, right after Earlier.
    mutating func moveAfter(_ Earlier: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Drops all uses that belong to this instruction.
    mutating func dropAllReferences()

    /// Replace all uses of all results of this instruction with undef.
    mutating func replaceAllUsesOfAllResultsWithUndef()

    /// Replace all uses of all results of this instruction
    /// with the parwise-corresponding results of the given instruction.
    mutating func replaceAllUsesPairwiseWith(_ other: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Replace all uses of all results of this instruction with the
    /// parwise-corresponding results of the passed in array.
    mutating func replaceAllUsesPairwiseWith(_ NewValues: UnsafePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>)

    /// Are there uses of any of the results of this instruction?
    mutating func hasUsesOfAnyResult() -> Bool

    /// Return the array of operands for this instruction.
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Return the array of type dependent operands for this instruction.
    ///
    /// Type dependent operands are hidden operands, i.e. not part of the SIL
    /// syntax (although they are printed as "type-defs" in comments).
    /// Their purpose is to establish a def-use relationship between
    ///   -) an instruction/argument which defines a type, e.g. open_existential
    /// and
    ///   -) this instruction, which uses the type, but doesn't use the defining
    ///      instruction as value-operand, e.g. a type in the substitution list.
    ///
    /// Currently there are two kinds of type dependent operands:
    ///
    /// 1. for opened archetypes:
    ///     %o = open_existential_addr %0 : $*P to $*@opened("UUID") P
    ///     %w = witness_method $@opened("UUID") P, ... // type-defs: %o
    ///
    /// 2. for the dynamic self argument:
    ///     sil @foo : $@convention(method) (@thick X.Type) {
    ///     bb0(%0 : $@thick X.Type):
    ///       %a = apply %f<@dynamic_self X>() ... // type-defs: %0
    ///
    /// The type dependent operands are just there to let optimizations know that
    /// there is a dependency between the instruction/argument which defines the
    /// type and the instruction which uses the type.
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Return the array of mutable operands for this instruction.
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Return the array of mutable type dependent operands for this instruction.
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getNumOperands() -> UInt32
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func isTypeDependentOperand(_ i: UInt32) -> Bool
    mutating func isTypeDependentOperand(_ Op: UnsafePointer<swift.Operand>) -> Bool

    /// Returns true if evaluation of this instruction may cause suspension of an
    /// async task.
    mutating func maySuspend() -> Bool
    mutating func getOperandValues(_ skipTypeDependentOperands: Bool) -> swift.SILInstruction.OperandValueRange
    mutating func getOperand(_ Num: UInt32) -> swift.SILValue
    mutating func setOperand(_ Num: UInt32, _ V: swift.SILValue)
    mutating func swapOperands(_ Num1: UInt32, _ Num2: UInt32)
    mutating func getOperandTypes() -> swift.SILInstruction.OperandTypeRange

    /// Return the list of results produced by this instruction.
    mutating func hasResults() -> Bool
    mutating func getResults() -> swift.SILInstructionResultArray
    mutating func getNumResults() -> UInt32
    mutating func getResult(_ index: UInt32) -> swift.SILValue

    /// Return the types of the results produced by this instruction.
    mutating func getResultTypes() -> swift.SILInstructionResultArray.type_range
    mutating func getMemoryBehavior() -> swift.SILInstruction.MemoryBehavior
    mutating func getReleasingBehavior() -> swift.SILInstruction.ReleasingBehavior

    /// Returns true if the instruction may release any object.
    mutating func mayRelease() -> Bool

    /// Returns true if the instruction may release or may read the reference
    /// count of any object.
    mutating func mayReleaseOrReadRefCount() -> Bool

    /// Can this instruction abort the program in some manner?
    mutating func mayTrap() -> Bool

    /// Returns true if the given instruction is completely identical to RHS.
    mutating func isIdenticalTo(_ RHS: UnsafePointer<swift.SILInstruction>!) -> Bool

    /// Returns true if the given instruction is completely identical to RHS,
    /// using \p opEqual to compare operands.
    ///
    mutating func isIdenticalTo<OpCmp>(_ RHS: UnsafePointer<swift.SILInstruction>!, _ opEqual: UnsafeMutablePointer<OpCmp>) -> Bool

    /// Returns true if the instruction may have side effects.
    ///
    /// Instructions that store into memory or change retain counts as well as
    /// calls and deallocation instructions are considered to have side effects
    /// that are not visible by merely examining their uses.
    mutating func mayHaveSideEffects() -> Bool

    /// Returns true if the instruction may write to memory.
    mutating func mayWriteToMemory() -> Bool

    /// Returns true if the instruction may read from memory.
    mutating func mayReadFromMemory() -> Bool

    /// Returns true if the instruction may read from or write to memory.
    mutating func mayReadOrWriteMemory() -> Bool

    /// Return true if the instruction is "pure" in the sense that it may execute
    /// multiple times without affecting behavior. This implies that it can be
    /// trivially cloned at multiple use sites without preserving path
    /// equivalence.
    mutating func isPure() -> Bool

    /// Returns true if the result of this instruction is a pointer to stack
    /// allocated memory. In this case there must be an adjacent deallocating
    /// instruction.
    mutating func isAllocatingStack() -> Bool

    /// Returns true if this is the deallocation of a stack allocating instruction.
    /// The first operand must be the allocating instruction.
    mutating func isDeallocatingStack() -> Bool

    /// Create a new copy of this instruction, which retains all of the operands
    /// and other information of this one.  If an insertion point is specified,
    /// then the new instruction is inserted before the specified point, otherwise
    /// the new instruction is returned without a parent.
    mutating func clone(_ InsertPt: UnsafeMutablePointer<swift.SILInstruction>!) -> UnsafeMutablePointer<swift.SILInstruction>!

    /// Invoke an Instruction's destructor. This dispatches to the appropriate
    /// leaf class destructor for the type of the instruction. This does not
    /// deallocate the instruction.
    static func destroy(_ I: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Returns true if the instruction can be duplicated without any special
    /// additional handling. It is important to know this information when
    /// you perform such optimizations like e.g. jump-threading.
    mutating func isTriviallyDuplicatable() -> Bool

    /// Returns true if the instruction is only relevant for debug
    /// informations and has no other impact on program semantics.
    mutating func isDebugInstruction() -> Bool

    /// Returns true if the instruction is a meta instruction which is
    /// relevant for debug information and does not get lowered to a real
    /// instruction.
    mutating func isMetaInstruction() -> Bool

    /// Verify that all operands of this instruction have compatible ownership
    /// with this instruction.
    mutating func verifyOperandOwnership()

    /// Get the number of created SILInstructions.
    static func getNumCreatedInstructions() -> Int32

    /// Get the number of deleted SILInstructions.
    static func getNumDeletedInstructions() -> Int32

    /// Pretty-print the value.
    mutating func dump()
    @warn_unqualified_access
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)

    /// Pretty-print the value in context, preceded by its operands (if the
    /// value represents the result of an instruction) and followed by its
    /// users.
    mutating func dumpInContext()
    mutating func printInContext(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SILInstruction>!) -> Bool
  }

  /// Try to simplify the specified instruction, performing local
  /// analysis of the operands of the instruction, without looking at its uses
  /// (e.g. constant folding).  If a simpler result can be found, it is
  /// returned, otherwise a null SILValue is returned.
  ///
  /// This is assumed to implement read-none transformations.
  static func simplifyInstruction(_ I: UnsafeMutablePointer<swift.SILInstruction>!) -> swift.SILValue

  /// Replace an instruction with a simplified result and erase it. If the
  /// instruction initiates a scope, do not replace the end of its scope; it will
  /// be deleted along with its parent.
  ///
  /// If it is nonnull, eraseNotify will be called before each instruction is
  /// deleted.
  ///
  /// If it is nonnull and inst is in OSSA, newInstNotify will be called with each
  /// new instruction inserted to compensate for ownership.
  ///
  /// NOTE: When OSSA is enabled this API assumes OSSA is properly formed and will
  /// insert compensating instructions.
  static func replaceAllSimplifiedUsesAndErase(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ result: swift.SILValue, _ eraseNotify: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ newInstNotify: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift14SILInstructionEEEE, _ deadEndBlocks: OpaquePointer!) -> swift.SILBasicBlock.iterator

  /// Simplify invocations of builtin operations that may overflow.
  /// All such operations return a tuple (result, overflow_flag).
  /// This function try to simplify such operations, but returns only a
  /// simplified first element of a tuple. The overflow flag is not returned
  /// explicitly, because this simplification is only possible if there is
  /// no overflow. Therefore the overflow flag is known to have a value of 0 if
  /// simplification was successful.
  /// In case when a simplification is not possible, a null SILValue is returned.
  static func simplifyOverflowBuiltinInstruction(_ BI: UnsafeMutablePointer<swift.BuiltinInst>!) -> swift.SILValue

  /// EpilogueARCBlockState - Keep track of whether an epilogue ARC instruction
  /// has been found.
  struct EpilogueARCBlockState {

    /// Keep track of whether an epilogue release has been found before and after
    /// this basic block.
    var BBSetIn: Bool

    /// The basic block local SILValue we are interested to find epilogue ARC in.
    var LocalArg: swift.SILValue

    /// Constructor, we only compute epilogue ARC instruction for 1 argument at
    /// a time.
    /// Optimistic data flow.
    init()
  }

  /// EpilogueARCContext - This class implements a data flow with which epilogue
  /// retains or releases for a SILValue are found.
  ///
  /// NOTE:
  /// In case of release finder, this function assumes the SILArgument has
  /// @owned semantic.
  /// In case of retain finder, this class assumes Arg is one of the return value
  /// of the function.
  struct EpilogueARCContext {
    struct EpilogueARCKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }

    /// Constructor.
    init(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ PO: UnsafeMutablePointer<swift.PostOrderAnalysis>!, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!, _ RCIA: UnsafeMutablePointer<swift.RCIdentityAnalysis>!)

    /// Run the data flow to find the epilogue retains or releases.
    mutating func run(_ NewKind: swift.EpilogueARCContext.EpilogueARCKind, _ NewArg: swift.SILValue) -> Bool

    /// Reset the epilogue arc instructions. 
    mutating func getEpilogueARCInsts() -> llvm.__CxxTemplateInstN4llvm14SmallSetVectorIPN5swift14SILInstructionELj1EEE
    mutating func reset()

    /// Initialize the data flow.
    mutating func initializeDataflow()

    /// Keep iterating until the data flow is converged.
    mutating func convergeDataflow() -> Bool

    /// Find the epilogue ARC instructions.
    mutating func computeEpilogueARC() -> Bool

    /// This instruction prevents looking further for epilogue retains on the
    /// current path.
    mutating func mayBlockEpilogueRetain(_ II: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue) -> Bool

    /// This instruction prevents looking further for epilogue releases on the
    /// current path.
    mutating func mayBlockEpilogueRelease(_ II: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue) -> Bool

    /// Does this instruction block the interested ARC instruction ?
    mutating func mayBlockEpilogueARC(_ II: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue) -> Bool

    /// This is the type of instructions the data flow is interested in.
    mutating func isInterestedInstruction(_ II: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool
  }

  /// This class is a simple wrapper around an identity cache.
  struct EpilogueARCFunctionInfo {

    /// Constructor.
    init(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ PO: UnsafeMutablePointer<swift.PostOrderAnalysis>!, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!, _ RC: UnsafeMutablePointer<swift.RCIdentityAnalysis>!)
    mutating func handleDeleteNotification(_ node: UnsafeMutablePointer<swift.SILNode>!)

    /// Find the epilogue ARC instruction based on the given \p Kind and given
    /// \p Arg.
    mutating func computeEpilogueARCInstructions(_ Kind: swift.EpilogueARCContext.EpilogueARCKind, _ Arg: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm14SmallSetVectorIPN5swift14SILInstructionELj1EEE
  }
  struct EpilogueARCAnalysis {
    init(_: UnsafeMutablePointer<swift.SILModule>!)
    mutating func handleDeleteNotification(_ node: UnsafeMutablePointer<swift.SILNode>!)
    mutating func needsNotifications() -> Bool
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
    mutating func initialize(_ PM: UnsafeMutablePointer<swift.SILPassManager>!)
    mutating func newFunctionAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift23EpilogueARCFunctionInfoENS_14default_deleteIS2_EEEE
    mutating func shouldInvalidate(_ K: swift.SILAnalysis.InvalidationKind) -> Bool
  }

  /// A SIL module. The SIL module owns all of the SILFunctions generated
  /// when a Swift compilation context is lowered to SIL.
  struct SILModule {
    typealias VTableListType = llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9SILVTableEEE
    typealias CoverageMapCollectionType = llvm.__CxxTemplateInstN4llvm9MapVectorINS_9StringRefEPN5swift14SILCoverageMapENS_8DenseMapIS1_jNS_12DenseMapInfoIS1_EENS_6detail12DenseMapPairIS1_jEEEENSt3__16vectorINSC_4pairIS1_S4_EENSC_9allocatorISF_EEEEEE
    enum LinkingMode : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8

      /// Link functions with non-public linkage. Used by the mandatory pipeline.
      case LinkNormal

      /// Link all functions. Used by the performance pipeine.
      case LinkAll
    }
    typealias ActionCallback = std.__1.__CxxTemplateInstNSt3__18functionIFvvEEE
    typealias iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift11SILFunctionELb1ELb0EvEELb0ELb0EEE
    typealias const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift11SILFunctionELb1ELb0EvEELb0ELb1EEE
    typealias vtable_iterator = llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9SILVTableEEE.iterator
    typealias vtable_const_iterator = llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9SILVTableEEE.const_iterator
    typealias witness_table_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift15SILWitnessTableELb1ELb0EvEELb0ELb0EEE
    typealias witness_table_const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift15SILWitnessTableELb1ELb0EvEELb0ELb1EEE
    typealias default_witness_table_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift22SILDefaultWitnessTableELb1ELb0EvEELb0ELb0EEE
    typealias default_witness_table_const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift22SILDefaultWitnessTableELb1ELb0EvEELb0ELb1EEE
    typealias differentiability_witness_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift27SILDifferentiabilityWitnessELb1ELb0EvEELb0ELb0EEE
    typealias differentiability_witness_const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift27SILDifferentiabilityWitnessELb1ELb0EvEELb0ELb1EEE
    typealias sil_global_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift17SILGlobalVariableELb1ELb0EvEELb0ELb0EEE
    typealias sil_global_const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift17SILGlobalVariableELb1ELb0EvEELb0ELb1EEE

    /// This converts Swift types to SILTypes.
    var Types: UnsafeMutablePointer<swift.Lowering.TypeConverter>

    /// Method which returns the SerializedSILLoader, creating the loader if it
    /// has not been created yet.
    mutating func getSILLoader() -> OpaquePointer!

    /// Add a callback for each newly deserialized SIL function body.
    mutating func registerDeserializationNotificationHandler(_ handler: UnsafeMutablePointer<std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift34DeserializationNotificationHandlerENS_14default_deleteIS2_EEEE>)

    /// Return the set of registered deserialization callbacks.
    mutating func getDeserializationHandlers() -> swift.DeserializationNotificationHandlerSet.range
    mutating func removeDeserializationNotificationHandler(_ handler: UnsafeMutablePointer<swift.DeserializationNotificationHandler>!)
    mutating func hasRegisteredDeserializationNotificationHandlerForNonTransparentFuncOME() -> Bool
    mutating func hasRegisteredDeserializationNotificationHandlerForAllFuncOME() -> Bool
    mutating func setRegisteredDeserializationNotificationHandlerForNonTransparentFuncOME()
    mutating func setRegisteredDeserializationNotificationHandlerForAllFuncOME()

    /// Add a delete notification handler \p Handler to the module context.
    mutating func registerDeleteNotificationHandler(_ Handler: UnsafeMutablePointer<swift.DeleteNotificationHandler>!)

    /// Remove the delete notification handler \p Handler from the module context.
    mutating func removeDeleteNotificationHandler(_ Handler: UnsafeMutablePointer<swift.DeleteNotificationHandler>!)

    /// Send the invalidation message that \p V is being deleted to all
    /// registered handlers. The order of handlers is deterministic but arbitrary.
    mutating func notifyDeleteHandlers(_ node: UnsafeMutablePointer<swift.SILNode>!)

    /// Set a serialization action.
    mutating func setSerializeSILAction(_ SerializeSILAction: swift.SILModule.ActionCallback)
    mutating func getSerializeSILAction() -> swift.SILModule.ActionCallback

    /// Set a flag indicating that this module is serialized already.
    mutating func setSerialized()
    mutating func isSerialized() -> Bool

    /// Serialize a SIL module using the configured SerializeSILAction.
    mutating func serialize()

    /// Invalidate cached entries in SIL Loader.
    mutating func invalidateSILLoaderCaches()

    /// Erase a function from the module.
    mutating func eraseFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Invalidate a function in SILLoader cache.
    mutating func invalidateFunctionInSILCache(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Specialization can cause a function that was erased before by dead function
    /// elimination to become alive again. If this happens we need to remove it
    /// from the list of zombies.
    mutating func removeFromZombieList(_ Name: llvm.StringRef) -> UnsafeMutablePointer<swift.SILFunction>!

    /// Erase a global SIL variable from the module.
    mutating func eraseGlobalVariable(_ G: UnsafeMutablePointer<swift.SILGlobalVariable>!)

    /// Get the Swift module associated with this SIL module.
    mutating func getSwiftModule() -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Get the AST context used for type uniquing etc. by this SIL module.
    mutating func getASTContext() -> UnsafeMutablePointer<swift.ASTContext>
    mutating func getSourceManager() -> UnsafeMutablePointer<swift.SourceManager>

    /// Get the Swift DeclContext associated with this SIL module. This is never
    /// null.
    ///
    /// All AST declarations within this context are assumed to have been fully
    /// processed as part of generating this module. This allows certain passes
    /// to make additional assumptions about these declarations.
    ///
    /// If this is the same as TheSwiftModule, the entire module is being
    /// compiled as a single unit.
    mutating func getAssociatedContext() -> UnsafePointer<swift.DeclContext>!

    /// Returns true if this SILModule really contains the whole module, i.e.
    /// optimizations can assume that they see the whole module.
    mutating func isWholeModule() -> Bool
    mutating func isStdlibModule() -> Bool

    /// Returns true if it is the optimized OnoneSupport module.
    mutating func isOptimizedOnoneSupportModule() -> Bool
    mutating func getOptions() -> UnsafePointer<swift.SILOptions>
    mutating func begin() -> swift.SILModule.iterator
    mutating func end() -> swift.SILModule.iterator
    mutating func begin() -> swift.SILModule.const_iterator
    mutating func end() -> swift.SILModule.const_iterator
    mutating func getFunctions() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift11SILFunctionELb1ELb0EvEELb0ELb0EEEEE
    mutating func getFunctions() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift11SILFunctionELb1ELb0EvEELb0ELb1EEEEE
    mutating func zombies_begin() -> swift.SILModule.const_iterator
    mutating func zombies_end() -> swift.SILModule.const_iterator
    mutating func getVTables() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9SILVTableEEE
    mutating func vtable_begin() -> swift.SILModule.vtable_iterator!
    mutating func vtable_end() -> swift.SILModule.vtable_iterator!
    mutating func vtable_begin() -> swift.SILModule.vtable_const_iterator!
    mutating func vtable_end() -> swift.SILModule.vtable_const_iterator!
    mutating func witness_table_begin() -> swift.SILModule.witness_table_iterator
    mutating func witness_table_end() -> swift.SILModule.witness_table_iterator
    mutating func witness_table_begin() -> swift.SILModule.witness_table_const_iterator
    mutating func witness_table_end() -> swift.SILModule.witness_table_const_iterator
    mutating func getWitnessTables() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift15SILWitnessTableELb1ELb0EvEELb0ELb0EEEEE
    mutating func getWitnessTables() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift15SILWitnessTableELb1ELb0EvEELb0ELb1EEEEE
    mutating func default_witness_table_begin() -> swift.SILModule.default_witness_table_iterator
    mutating func default_witness_table_end() -> swift.SILModule.default_witness_table_iterator
    mutating func default_witness_table_begin() -> swift.SILModule.default_witness_table_const_iterator
    mutating func default_witness_table_end() -> swift.SILModule.default_witness_table_const_iterator
    mutating func getDefaultWitnessTables() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift22SILDefaultWitnessTableELb1ELb0EvEELb0ELb0EEEEE
    mutating func getDefaultWitnessTables() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift22SILDefaultWitnessTableELb1ELb0EvEELb0ELb1EEEEE
    mutating func differentiability_witness_begin() -> swift.SILModule.differentiability_witness_iterator
    mutating func differentiability_witness_end() -> swift.SILModule.differentiability_witness_iterator
    mutating func differentiability_witness_begin() -> swift.SILModule.differentiability_witness_const_iterator
    mutating func differentiability_witness_end() -> swift.SILModule.differentiability_witness_const_iterator
    mutating func getDifferentiabilityWitnesses() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift27SILDifferentiabilityWitnessELb1ELb0EvEELb0ELb0EEEEE
    mutating func getDifferentiabilityWitnesses() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift27SILDifferentiabilityWitnessELb1ELb0EvEELb0ELb1EEEEE
    mutating func addExternallyVisibleDecl(_ decl: UnsafeMutablePointer<swift.ValueDecl>!)
    mutating func isExternallyVisibleDecl(_ decl: UnsafeMutablePointer<swift.ValueDecl>!) -> Bool
    mutating func sil_global_begin() -> swift.SILModule.sil_global_iterator
    mutating func sil_global_end() -> swift.SILModule.sil_global_iterator
    mutating func sil_global_begin() -> swift.SILModule.sil_global_const_iterator
    mutating func sil_global_end() -> swift.SILModule.sil_global_const_iterator
    mutating func getSILGlobals() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift17SILGlobalVariableELb1ELb0EvEELb0ELb0EEEEE
    mutating func getSILGlobals() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift17SILGlobalVariableELb1ELb0EvEELb0ELb1EEEEE
    mutating func getCoverageMaps() -> UnsafeMutablePointer<swift.SILModule.CoverageMapCollectionType>
    mutating func getCoverageMaps() -> UnsafePointer<swift.SILModule.CoverageMapCollectionType>
    mutating func getSILRemarkStreamer() -> OpaquePointer!
    mutating func installSILRemarkStreamer()
    mutating func isVisibleExternally(_ decl: UnsafePointer<swift.VarDecl>!) -> Bool

    /// Look for a global variable by name.
    ///
    /// \return null if this module has no such global variable
    mutating func lookUpGlobalVariable(_ name: llvm.StringRef) -> UnsafeMutablePointer<swift.SILGlobalVariable>!

    /// Look for a function by name.
    ///
    /// \return null if this module has no such function
    mutating func lookUpFunction(_ name: llvm.StringRef) -> UnsafeMutablePointer<swift.SILFunction>!

    /// Look for a function by declaration.
    ///
    /// \return null if this module has no such function
    mutating func lookUpFunction(_ fnRef: swift.SILDeclRef) -> UnsafeMutablePointer<swift.SILFunction>!

    /// Attempt to deserialize the SILFunction. Returns true if deserialization
    /// succeeded, false otherwise.
    mutating func loadFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> Bool

    /// Update the linkage of the SILFunction with the linkage of the serialized
    /// function.
    ///
    /// The serialized SILLinkage can differ from the linkage derived from the
    /// AST, e.g. cross-module-optimization can change the SIL linkages.
    mutating func updateFunctionLinkage(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Attempt to link the SILFunction. Returns true if linking succeeded, false
    /// otherwise.
    ///
    /// \return false if the linking failed.
    mutating func linkFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ LinkMode: swift.SILModule.LinkingMode) -> Bool

    /// Check if a given function exists in any of the modules with a
    /// required linkage, i.e. it can be linked by linkFunction.
    ///
    /// \return null if this module has no such function. Otherwise
    /// the declaration of a function.
    mutating func findFunction(_ Name: llvm.StringRef, _ Linkage: swift.SILLinkage) -> UnsafeMutablePointer<swift.SILFunction>!

    /// Check if a given function exists in any of the modules.
    /// i.e. it can be linked by linkFunction.
    mutating func hasFunction(_ Name: llvm.StringRef) -> Bool

    /// Look up the SILWitnessTable representing the lowering of a protocol
    /// conformance, and collect the substitutions to apply to the referenced
    /// witnesses, if any.
    ///
    /// \arg C The protocol conformance mapped key to use to lookup the witness
    ///        table.
    /// \arg deserializeLazily If we cannot find the witness table should we
    ///                        attempt to lazily deserialize it.
    mutating func lookUpWitnessTable(_ C: swift.ProtocolConformanceRef, _ deserializeLazily: Bool) -> UnsafeMutablePointer<swift.SILWitnessTable>!
    mutating func lookUpWitnessTable(_ C: OpaquePointer!, _ deserializeLazily: Bool) -> UnsafeMutablePointer<swift.SILWitnessTable>!

    /// Look up the SILDefaultWitnessTable representing the default witnesses
    /// of a resilient protocol, if any.
    mutating func lookUpDefaultWitnessTable(_ Protocol: UnsafePointer<swift.ProtocolDecl>!, _ deserializeLazily: Bool) -> UnsafeMutablePointer<swift.SILDefaultWitnessTable>!

    /// Look up the VTable mapped to the given ClassDecl. Returns null on failure.
    mutating func lookUpVTable(_ C: UnsafePointer<swift.ClassDecl>!, _ deserializeLazily: Bool) -> UnsafeMutablePointer<swift.SILVTable>!

    /// Attempt to lookup the function corresponding to \p Member in the class
    /// hierarchy of \p Class.
    mutating func lookUpFunctionInVTable(_ Class: UnsafeMutablePointer<swift.ClassDecl>!, _ Member: swift.SILDeclRef) -> UnsafeMutablePointer<swift.SILFunction>!

    /// Look up the differentiability witness with the given name.
    mutating func lookUpDifferentiabilityWitness(_ name: llvm.StringRef) -> UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!

    /// Attempt to deserialize the SILDifferentiabilityWitness. Returns true if
    /// deserialization succeeded, false otherwise.
    mutating func loadDifferentiabilityWitness(_ dw: UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!) -> Bool
    mutating func createDefaultWitnessTableDeclaration(_ Protocol: UnsafePointer<swift.ProtocolDecl>!, _ Linkage: swift.SILLinkage) -> UnsafeMutablePointer<swift.SILDefaultWitnessTable>!

    /// Deletes a dead witness table.
    mutating func deleteWitnessTable(_ Wt: UnsafeMutablePointer<swift.SILWitnessTable>!)

    /// Return the stage of processing this module is at.
    mutating func getStage() -> swift.SILStage

    /// Advance the module to a further stage of processing.
    mutating func setStage(_ s: swift.SILStage)
    mutating func getPGOReader() -> UnsafeMutablePointer<llvm.IndexedInstrProfReader>!
    mutating func setPGOReader(_ IPR: std.__1.__CxxTemplateInstNSt3__110unique_ptrIN4llvm22IndexedInstrProfReaderENS_14default_deleteIS2_EEEE)
    mutating func getIndexTrieRoot() -> UnsafeMutablePointer<swift.IndexTrieNode>!

    /// Can value operations (copies and destroys) on the given lowered type
    /// be performed in this module?
    mutating func isTypeABIAccessible(_ type: swift.SILType, _ forExpansion: swift.TypeExpansionContext) -> Bool

    /// Can type metadata for the given formal type be fetched in
    /// the given module?
    mutating func isTypeMetadataAccessible(_ type: swift.CanType) -> Bool

    /// Can type metadata necessary for value operations for the given sil type be
    /// fetched in the given module?
    mutating func isTypeMetadataForLayoutAccessible(_ type: swift.SILType) -> Bool

    /// Run the SIL verifier to make sure that all Functions follow
    /// invariants.
    mutating func verify()

    /// Check if there are any leaking instructions.
    ///
    /// Aborts with an error if more instructions are allocated than contained in
    /// the module.
    mutating func checkForLeaks()

    /// Check if there are any leaking instructions after the SILModule is
    /// destructed.
    ///
    /// The SILModule destructor already calls checkForLeaks(). This function is
    /// useful to check if the destructor itself destroys all data structures.
    static func checkForLeaksAfterDestruction()

    /// Pretty-print the module.
    mutating func dump(_ Verbose: Bool)

    /// Pretty-print the module to a file.
    /// Useful for dumping the module when running in a debugger.
    /// Warning: no error handling is done. Fails with an assert if the file
    /// cannot be opened.
    mutating func dump(_ FileName: UnsafePointer<CChar>!, _ Verbose: Bool, _ PrintASTDecls: Bool)

    /// Pretty-print the module to the designated stream.
    ///
    /// \param M If present, the types and declarations from this module will be
    ///        printed. The module would usually contain the types and Decls that
    ///        the SIL module depends on.
    /// \param Opts The SIL options, used to determine printing verbosity and
    ///        and sorting.
    /// \param PrintASTDecls If set to true print AST decls.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ M: UnsafeMutablePointer<swift.ModuleDecl>!, _ Opts: UnsafePointer<swift.SILOptions>, _ PrintASTDecls: Bool)

    /// Pretty-print the module with the context \p PrintCtx.
    ///
    /// \param M If present, the types and declarations from this module will be
    ///        printed. The module would usually contain the types and Decls that
    ///        the SIL module depends on.
    /// \param PrintASTDecls If set to true print AST decls.
    mutating func print(_ PrintCtx: UnsafeMutablePointer<swift.SILPrintContext>, _ M: UnsafeMutablePointer<swift.ModuleDecl>!, _ PrintASTDecls: Bool)

    /// Allocate memory using the module's internal allocator.
    mutating func allocate(_ Size: UInt32, _ Align: UInt32) -> UnsafeMutableRawPointer!
    mutating func allocate<T>(_ Count: UInt32) -> OpaquePointer!
    mutating func allocateCopy(_ Str: llvm.StringRef) -> llvm.StringRef

    /// Allocate memory for an instruction using the module's internal allocator.
    mutating func allocateInst(_ Size: UInt32, _ Align: UInt32) -> UnsafeMutableRawPointer!

    /// Deallocate memory of an instruction.
    mutating func deallocateInst(_ I: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Looks up the llvm intrinsic ID and type for the builtin function.
    ///
    /// \returns Returns llvm::Intrinsic::not_intrinsic if the function is not an
    /// intrinsic. The particular intrinsic functions which correspond to the
    /// returned value are defined in llvm/Intrinsics.h.
    mutating func getIntrinsicInfo(_ ID: swift.Identifier) -> UnsafePointer<swift.IntrinsicInfo>

    /// Looks up the lazily cached identification for the builtin function.
    ///
    /// \returns Returns builtin info of BuiltinValueKind::None kind if the
    /// declaration is not a builtin.
    mutating func getBuiltinInfo(_ ID: swift.Identifier) -> UnsafePointer<swift.BuiltinInfo>

    /// Returns true if the builtin or intrinsic is no-return.
    mutating func isNoReturnBuiltinOrIntrinsic(_ Name: swift.Identifier) -> Bool

    /// Returns true if the default atomicity of the module is Atomic.
    mutating func isDefaultAtomic() -> Bool

    /// Returns true if SIL entities associated with declarations in the given
    /// declaration context ought to be serialized as part of this module.
    mutating func shouldSerializeEntitiesAssociatedWithDeclContext(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool
  }

  /// ClassDecl - This is the declaration of a class, for example:
  ///
  ///    class Complex { var R : Double, I : Double }
  ///
  /// The type of the decl itself is a MetatypeType; use getDeclaredType()
  /// to get the declared type ("Complex" in the above example).
  struct ClassDecl {

    /// \see getForeignClassKind
    enum ForeignKind : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8

      /// A normal Swift or Objective-C class.
      case Normal

      /// An imported Core Foundation type. These are AnyObject-compatible but
      /// do not have runtime metadata.
      case CFType

      /// An imported Objective-C type whose class and metaclass symbols are not
      /// both available at link-time but can be accessed through the Objective-C
      /// runtime.
      case RuntimeOnly
    }

    /// The type of metaclass to use for a class.
    enum MetaclassKind : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8
      case ObjC
      case SwiftStub
    }
    init(_ ClassLoc: swift.SourceLoc, _ Name: swift.Identifier, _ NameLoc: swift.SourceLoc, _ Inherited: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7TypeLocEEE, _ GenericParams: OpaquePointer!, _ DC: UnsafeMutablePointer<swift.DeclContext>!)
    mutating func getStartLoc() -> swift.SourceLoc
    mutating func getSourceRange() -> swift.SourceRange

    /// Determine whether the member area of this class's metadata (which consists
    /// of field offsets and vtable entries) is to be considered opaque by clients.
    ///
    /// Note that even @_fixed_layout classes have resilient metadata if they are
    /// in a resilient module.
    mutating func hasResilientMetadata() -> Bool

    /// Determine whether this class has resilient metadata when accessed from the
    /// given module and resilience expansion.
    mutating func hasResilientMetadata(_ M: UnsafeMutablePointer<swift.ModuleDecl>!, _ expansion: swift.ResilienceExpansion) -> Bool

    /// Determine whether this class has a superclass.
    mutating func hasSuperclass() -> Bool

    /// Retrieve the superclass of this class, or null if there is no superclass.
    mutating func getSuperclass() -> swift.`Type`

    /// Retrieve the ClassDecl for the superclass of this class, or null if there
    /// is no superclass.
    mutating func getSuperclassDecl() -> UnsafeMutablePointer<swift.ClassDecl>!

    /// Check if this class is a superclass or equal to the given class.
    mutating func isSuperclassOf(_ other: UnsafeMutablePointer<swift.ClassDecl>!) -> Bool

    /// Set the superclass of this class.
    mutating func setSuperclass(_ superclass: swift.`Type`)

    /// Walk this class and all of the superclasses of this class, transitively,
    /// invoking the callback function for each class.
    ///
    /// \param fn The callback function that will be invoked for each superclass.
    /// It can return \c Continue to continue the traversal. Returning
    /// \c SkipChildren halts the search and returns \c false, while returning
    /// \c Stop halts the search and returns \c true.
    ///
    /// \returns \c true if \c fn returned \c Stop for any class, \c false
    /// otherwise.
    mutating func walkSuperclasses(_ fn: llvm.__CxxTemplateInstN4llvm12function_refIFN5swift10TypeWalker6ActionEPNS1_9ClassDeclEEEE) -> Bool

    //// Whether this class requires all of its stored properties to
    //// have initializers in the class definition.
    mutating func requiresStoredPropertyInits() -> Bool

    /// Whether this class is "foreign", meaning that it is implemented
    /// by a runtime that Swift does not have first-class integration
    /// with.  This generally means that:
    ///   - class data is either abstracted or cannot be made to
    ///     fit with Swift's metatype schema, and/or
    ///   - there is no facility for subclassing or adding polymorphic
    ///     methods to the class.
    ///
    /// We may find ourselves wanting to break this bit into more
    /// precise chunks later.
    mutating func getForeignClassKind() -> swift.ClassDecl.ForeignKind
    mutating func setForeignClassKind(_ kind: swift.ClassDecl.ForeignKind)

    /// Returns true if this class is any kind of "foreign class".
    ///
    /// \see getForeignClassKind
    mutating func isForeign() -> Bool

    /// Whether the class is an actor.
    mutating func isActor() -> Bool

    /// Whether the class is (known to be) a default actor.
    mutating func isDefaultActor() -> Bool

    /// Whether the class is known to be a *root* default actor,
    /// i.e. the first class in its hierarchy that is a default actor.
    mutating func isRootDefaultActor() -> Bool

    /// Does this class explicitly declare any of the methods that
    /// would prevent it from being a default actor?
    mutating func hasExplicitCustomActorMethods() -> Bool

    /// Is this the NSObject class type?
    mutating func isNSObject() -> Bool

    /// Whether the class directly inherits from NSObject but should use
    /// Swift's native object model.
    mutating func isNativeNSObjectSubclass() -> Bool

    /// Whether the class uses the ObjC object model (reference counting,
    /// allocation, etc.) instead of the Swift model.
    mutating func usesObjCObjectModel() -> Bool

    /// Returns true if the class has designated initializers that are not listed
    /// in its members.
    ///
    /// This can occur, for example, if the class is an Objective-C class with
    /// initializers that cannot be represented in Swift.
    mutating func hasMissingDesignatedInitializers() -> Bool

    /// Returns true if the class has missing members that require vtable entries.
    ///
    /// In this case, the class cannot be subclassed, because we cannot construct
    /// the vtable for the subclass.
    mutating func hasMissingVTableEntries() -> Bool
    mutating func setHasMissingVTableEntries(_ newValue: Bool)

    /// Returns true if this class cannot be used with weak or unowned
    /// references.
    /// 
    /// Note that this is true if this class or any of its ancestor classes
    /// are marked incompatible.
    mutating func isIncompatibleWithWeakReferences() -> Bool
    mutating func setIsIncompatibleWithWeakReferences(_ newValue: Bool)

    /// Find a method of a class that overrides a given method.
    /// Return nullptr, if no such method exists.
    mutating func findOverridingDecl(_ method: UnsafePointer<swift.AbstractFunctionDecl>!) -> UnsafeMutablePointer<swift.AbstractFunctionDecl>!

    /// Find a method implementation which will be used when a given method
    /// is invoked on an instance of this class. This implementation may stem
    /// either from a class itself or its direct or indirect superclasses.
    mutating func findImplementingMethod(_ method: UnsafePointer<swift.AbstractFunctionDecl>!) -> UnsafeMutablePointer<swift.AbstractFunctionDecl>!

    /// Retrieve the destructor for this class.
    mutating func getDestructor() -> UnsafeMutablePointer<swift.DestructorDecl>!

    /// Determine whether this class inherits the convenience initializers
    /// from its superclass.
    mutating func inheritsSuperclassInitializers() -> Bool

    /// Walks the class hierarchy starting from this class, checking various
    /// conditions.
    mutating func checkAncestry() -> swift.AncestryOptions

    /// Check if the class has ancestry of the given kind.
    mutating func checkAncestry(_ flag: swift.AncestryFlags) -> Bool

    /// Determine which sort of metaclass to use for this class
    mutating func getMetaclassKind() -> swift.ClassDecl.MetaclassKind

    /// Retrieve the name to use for this class when interoperating with
    /// the Objective-C runtime.
    mutating func getObjCRuntimeName(_ buffer: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIcEE>) -> llvm.StringRef

    /// Record the presence of an @objc method with the given selector.
    mutating func recordObjCMethod(_ method: UnsafeMutablePointer<swift.AbstractFunctionDecl>!, _ selector: swift.ObjCSelector)
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.GenericTypeDecl>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.NominalTypeDecl>!) -> Bool
    static func classof(_ C: UnsafePointer<swift.DeclContext>!) -> Bool
    static func classof(_ C: UnsafePointer<swift.IterableDeclContext>!) -> Bool

    /// Returns true if the decl uses the Objective-C generics model.
    ///
    /// This is true of imported Objective-C classes.
    mutating func usesObjCGenericsModel() -> Bool

    /// True if the class is known to be implemented in Swift.
    mutating func hasKnownSwiftImplementation() -> Bool
  }
  struct ClassHierarchyAnalysis {
    typealias ClassList = llvm.__CxxTemplateInstN4llvm11SmallVectorIPN5swift9ClassDeclELj8EEE
    init(_ Mod: UnsafeMutablePointer<swift.SILModule>!)
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool

    /// Invalidate all information in this analysis.
    mutating func invalidate()

    /// Invalidate all of the information for a specific function.
    mutating func invalidate(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ K: swift.SILAnalysis.InvalidationKind)

    /// Notify the analysis about a newly created function.
    mutating func notifyAddedOrModifiedFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the analysis about a function which will be deleted from the
    /// module.
    mutating func notifyWillDeleteFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the analysis about changed witness or vtables.
    mutating func invalidateFunctionTables()

    /// Returns a list of the known direct subclasses of a class \p C in
    /// the current module.
    mutating func getDirectSubClasses(_ C: UnsafeMutablePointer<swift.ClassDecl>!) -> UnsafePointer<swift.ClassHierarchyAnalysis.ClassList>

    /// Returns a list of the known indirect subclasses of a class \p C in
    /// the current module.
    mutating func getIndirectSubClasses(_ C: UnsafeMutablePointer<swift.ClassDecl>!) -> UnsafePointer<swift.ClassHierarchyAnalysis.ClassList>

    /// Returns true if the class is inherited by another class in this module.
    mutating func hasKnownDirectSubclasses(_ C: UnsafeMutablePointer<swift.ClassDecl>!) -> Bool

    /// Returns true if the class is indirectly inherited by another class
    /// in this module.
    mutating func hasKnownIndirectSubclasses(_ C: UnsafeMutablePointer<swift.ClassDecl>!) -> Bool
  }

  /// Return true if this is a retain instruction.
  static func isRetainInstruction(_ II: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// Return true if this is a release instruction.
  static func isReleaseInstruction(_ II: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// \returns True if the user \p User decrements the ref count of \p Ptr.
  static func mayDecrementRefCount(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!) -> Bool

  /// \returns True if the \p User might use the pointer \p Ptr in a manner that
  /// requires \p Ptr to be alive before Inst or the release of Ptr may use memory
  /// accessed by \p User.
  static func mayHaveSymmetricInterference(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!) -> Bool

  /// \returns True if the \p User must use the pointer \p Ptr in a manner that
  /// requires \p Ptr to be alive before Inst.
  static func mustUseValue(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!) -> Bool

  /// Returns true if User must use Ptr in a guaranteed way.
  ///
  /// This means that assuming that everything is conservative, we can ignore the
  /// ref count effects of User on Ptr since we will only remove things over
  /// guaranteed parameters if we are known safe in both directions.
  static func mustGuaranteedUseValue(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!) -> Bool

  /// Returns true if \p Inst can never conservatively decrement reference counts.
  static func canNeverDecrementRefCounts(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// Returns true if \p Inst may access any indirect object either via an address
  /// or reference.
  ///
  /// If false is returned and \p Inst has an address or reference type operand,
  /// then \p Inst only operates on the value of the address itself, not the
  /// memory. i.e. it does not dereference the address.
  static func canUseObject(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

  /// \returns true if the user \p User may use \p Ptr in a manner that requires
  /// Ptr's life to be guaranteed to exist at this point.
  ///
  /// TODO: Better name.
  static func mayGuaranteedUseValue(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ Ptr: swift.SILValue, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!) -> Bool

  /// A class that attempts to match owned return value and corresponding
  /// epilogue retains for a specific function.
  ///
  /// If we can not find the retain in the return block, we will try to find
  /// in the predecessors. 
  ///
  /// The search stop when we encounter an instruction that may decrement
  /// the return'ed value, as we do not want to create a lifetime gap once the
  /// retain is moved.
  struct ConsumedResultToEpilogueRetainMatcher {

    /// The state on how retains are found in a basic block.
    enum FindRetainKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32

      ///< Did not find a retain.
      case None

      ///< Found a retain.
      case Found

      ///< Found a retain and its due to self-recursion.
      case Recursion

      ///< Found a blocking instructions, i.e. MayDecrement.
      case Blocked
    }
    typealias iterator = llvm.__CxxTemplateInstN4llvm13TinyPtrVectorIPN5swift14SILInstructionEEE.iterator
    typealias const_iterator = llvm.__CxxTemplateInstN4llvm13TinyPtrVectorIPN5swift14SILInstructionEEE.const_iterator
    typealias reverse_iterator = llvm.__CxxTemplateInstN4llvm13TinyPtrVectorIPN5swift14SILInstructionEEE.reverse_iterator
    typealias const_reverse_iterator = llvm.__CxxTemplateInstN4llvm13TinyPtrVectorIPN5swift14SILInstructionEEE.const_reverse_iterator

    /// Finds matching releases in the return block of the function \p F.
    init(_ RCFI: UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!, _ AA: UnsafeMutablePointer<swift.AliasAnalysis>!, _ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Finds matching releases in the provided block \p BB.
    mutating func findMatchingRetains(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func getEpilogueRetains() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift14SILInstructionEEE

    /// Recompute the mapping from argument to consumed arg.
    mutating func recompute()
    mutating func begin() -> swift.ConsumedResultToEpilogueRetainMatcher.iterator!
    mutating func end() -> swift.ConsumedResultToEpilogueRetainMatcher.iterator!
    mutating func begin() -> swift.ConsumedResultToEpilogueRetainMatcher.const_iterator!
    mutating func end() -> swift.ConsumedResultToEpilogueRetainMatcher.const_iterator!
    mutating func rbegin() -> swift.ConsumedResultToEpilogueRetainMatcher.reverse_iterator
    mutating func rend() -> swift.ConsumedResultToEpilogueRetainMatcher.reverse_iterator
    mutating func rbegin() -> swift.ConsumedResultToEpilogueRetainMatcher.const_reverse_iterator
    mutating func rend() -> swift.ConsumedResultToEpilogueRetainMatcher.const_reverse_iterator
    mutating func size() -> UInt32
    mutating func getRange() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeIPPN5swift14SILInstructionEEE
  }

  /// A class that attempts to match owned arguments and corresponding epilogue
  /// releases for a specific function.
  ///
  /// Only try to find the epilogue release in the return block.
  struct ConsumedArgToEpilogueReleaseMatcher {
    enum ExitKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case Return
      case Throw
    }

    /// Finds matching releases in the return block of the function \p F.
    init(_ RCFI: UnsafeMutablePointer<swift.RCIdentityFunctionInfo>!, _ F: UnsafeMutablePointer<swift.SILFunction>!, _ ArgumentConventions: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift21SILArgumentConventionEEE, _ Kind: swift.ConsumedArgToEpilogueReleaseMatcher.ExitKind)

    /// Finds matching releases in the provided block \p BB.
    mutating func findMatchingReleases(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func hasBlock() -> Bool
    mutating func isEpilogueRelease(_ i: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

    /// Return true if we've found some epilogue releases for the argument
    /// but not all.
    mutating func hasSomeReleasesForArgument(_ arg: UnsafeMutablePointer<swift.SILArgument>!) -> Bool
    mutating func isSingleRelease(_ arg: UnsafeMutablePointer<swift.SILArgument>!) -> Bool
    mutating func getSingleReleaseForArgument(_ arg: UnsafeMutablePointer<swift.SILArgument>!) -> UnsafeMutablePointer<swift.SILInstruction>!
    mutating func getSingleReleaseForArgument(_ value: swift.SILValue) -> UnsafeMutablePointer<swift.SILInstruction>!
    mutating func getReleasesForArgument(_ arg: UnsafeMutablePointer<swift.SILArgument>!) -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift14SILInstructionEEE
    mutating func getPartiallyPostDomReleaseSet(_ arg: UnsafeMutablePointer<swift.SILArgument>!) -> llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIPN5swift14SILInstructionEEEEE
    mutating func getReleasesForArgument(_ value: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift14SILInstructionEEE

    /// Recompute the mapping from argument to consumed arg.
    mutating func recompute()
    mutating func isSingleReleaseMatchedToArgument(_ inst: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool
  }

  /// Match a call to a trap BB with no ARC relevant side effects.
  static func isARCInertTrapBB(_ BB: UnsafePointer<swift.SILBasicBlock>!) -> Bool

  /// Get the single builtin "unsafeGuaranteedEnd" user of a builtin
  /// "unsafeGuaranteed"'s token.
  static func getUnsafeGuaranteedEndUser(_ UnsafeGuaranteedToken: swift.SILValue) -> UnsafeMutablePointer<swift.BuiltinInst>!

  /// Walk forwards from an unsafeGuaranteedEnd builtin instruction looking for a
  /// release on the reference returned by the matching unsafeGuaranteed builtin
  /// ignoring releases on the way.
  /// Return nullptr if no release is found.
  ///
  ///    %4 = builtin "unsafeGuaranteed"<Foo>(%0 : $Foo) : $(Foo, Builtin.Int8)
  ///    %5 = tuple_extract %4 : $(Foo, Builtin.Int8), 0
  ///    %6 = tuple_extract %4 : $(Foo, Builtin.Int8), 1
  ///    %12 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
  ///    strong_release %5 : $Foo // <-- Matching release.
  ///
  /// Alternatively, look for the release before the unsafeGuaranteedEnd.
  static func findReleaseToMatchUnsafeGuaranteedValue(_ UnsafeGuaranteedEndI: UnsafeMutablePointer<swift.SILInstruction>!, _ UnsafeGuaranteedI: UnsafeMutablePointer<swift.SILInstruction>!, _ UnsafeGuaranteedValue: swift.SILValue, _ BB: UnsafeMutablePointer<swift.SILBasicBlock>, _ RCFI: UnsafeMutablePointer<swift.RCIdentityFunctionInfo>) -> UnsafeMutablePointer<swift.SILInstruction>!

  /// This class is a simple wrapper around an alias analysis cache. This is
  /// needed since we do not have an "analysis" infrastructure.
  struct AliasAnalysis {

    /// This enum describes the different kinds of aliasing relations between
    /// pointers.
    ///
    /// NoAlias: There is never dependence between memory referenced by the two
    ///          pointers. Example: Two pointers pointing to non-overlapping
    ///          memory ranges.
    ///
    /// MayAlias: Two pointers might refer to the same memory location.
    ///
    ///
    /// PartialAlias: The two memory locations are known to be overlapping
    ///               but do not start at the same address.
    ///
    ///
    /// MustAlias: The two memory locations always start at exactly the same
    ///            location. The pointers are equal.
    ///
    enum AliasResult : UInt32 {
      init?(rawValue: UInt32)
      var rawValue: UInt32 { get }
      typealias RawValue = UInt32

      ///< The two values have no dependencies on each
      case NoAlias

      ///< The two values cannot be proven to alias or
      case MayAlias

      ///< The two values overlap in a partial manner.
      case PartialAlias

      ///< The two values are equal.
      case MustAlias
    }
    init(_ M: UnsafeMutablePointer<swift.SILModule>!)
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
    mutating func initialize(_ PM: UnsafeMutablePointer<swift.SILPassManager>!)

    /// Explicitly invalidate an instruction.
    ///
    /// This can be useful to update the alias analysis within a pass.
    /// It's needed if e.g. \p inst is an address projection and its operand gets
    /// replaced with a different underlying object.
    mutating func invalidateInstruction(_ inst: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Perform an alias query to see if V1, V2 refer to the same values.
    mutating func alias(_ V1: swift.SILValue, _ V2: swift.SILValue, _ TBAAType1: swift.SILType, _ TBAAType2: swift.SILType) -> swift.AliasAnalysis.AliasResult

    /// Convenience method that returns true if V1 and V2 must alias.
    mutating func isMustAlias(_ V1: swift.SILValue, _ V2: swift.SILValue, _ TBAAType1: swift.SILType, _ TBAAType2: swift.SILType) -> Bool

    /// Convenience method that returns true if V1 and V2 partially alias.
    mutating func isPartialAlias(_ V1: swift.SILValue, _ V2: swift.SILValue, _ TBAAType1: swift.SILType, _ TBAAType2: swift.SILType) -> Bool

    /// Convenience method that returns true if V1, V2 cannot alias.
    mutating func isNoAlias(_ V1: swift.SILValue, _ V2: swift.SILValue, _ TBAAType1: swift.SILType, _ TBAAType2: swift.SILType) -> Bool

    /// Convenience method that returns true if V1, V2 may alias.
    mutating func isMayAlias(_ V1: swift.SILValue, _ V2: swift.SILValue, _ TBAAType1: swift.SILType, _ TBAAType2: swift.SILType) -> Bool

    /// \returns True if the release of the \p releasedReference can access or
    /// free memory accessed by \p User.
    mutating func mayValueReleaseInterfereWithInstruction(_ User: UnsafeMutablePointer<swift.SILInstruction>!, _ releasedReference: swift.SILValue) -> Bool

    /// Use the alias analysis to determine the memory behavior of Inst with
    /// respect to V.
    mutating func computeMemoryBehavior(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ V: swift.SILValue) -> swift.SILInstruction.MemoryBehavior

    /// Use the alias analysis to determine the memory behavior of Inst with
    /// respect to V.
    mutating func computeMemoryBehaviorInner(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ V: swift.SILValue) -> swift.SILInstruction.MemoryBehavior

    /// Returns true if \p Inst may read from memory in a manner that
    /// affects V.
    mutating func mayReadFromMemory(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ V: swift.SILValue) -> Bool

    /// Returns true if \p Inst may write to memory in a manner that
    /// affects V.
    mutating func mayWriteToMemory(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ V: swift.SILValue) -> Bool

    /// Returns true if \p Inst may read or write to memory in a manner that
    /// affects V.
    mutating func mayReadOrWriteMemory(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ V: swift.SILValue) -> Bool

    /// Returns true if \p Ptr may be released in the function call \p FAS.
    mutating func canApplyDecrementRefCount(_ FAS: swift.FullApplySite, _ Ptr: swift.SILValue) -> Bool

    /// Returns true if \p Ptr may be released by the builtin \p BI.
    mutating func canBuiltinDecrementRefCount(_ BI: UnsafeMutablePointer<swift.BuiltinInst>!, _ Ptr: swift.SILValue) -> Bool
    mutating func invalidate()
    mutating func invalidate(_: UnsafeMutablePointer<swift.SILFunction>!, _ K: swift.SILAnalysis.InvalidationKind)

    /// Notify the analysis about a newly created function.
    mutating func notifyAddedOrModifiedFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the analysis about a function which will be deleted from the
    /// module.
    mutating func notifyWillDeleteFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func invalidateFunctionTables()
  }

  /// This class is a simple wrapper around the POT iterator provided by LLVM. It
  /// lazily re-evaluates the post order when it is invalidated so that we do not
  /// reform the post order over and over again (it can be expensive).
  struct PostOrderAnalysis {
    init()
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
  }
  struct RCIdentityAnalysis {
    init(_: UnsafeMutablePointer<swift.SILModule>!)
    mutating func handleDeleteNotification(_ node: UnsafeMutablePointer<swift.SILNode>!)
    mutating func needsNotifications() -> Bool
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
    mutating func initialize(_ PM: UnsafeMutablePointer<swift.SILPassManager>!)
    mutating func newFunctionAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift22RCIdentityFunctionInfoENS_14default_deleteIS2_EEEE
    mutating func shouldInvalidate(_ K: swift.SILAnalysis.InvalidationKind) -> Bool
  }

  /// This class is a simple wrapper around an identity cache.
  struct RCIdentityFunctionInfo {
    init(_ D: UnsafeMutablePointer<swift.DominanceAnalysis>!)
    mutating func getRCIdentityRoot(_ V: swift.SILValue) -> swift.SILValue

    /// A helper method that calls getRCUses and then maps each operand to the
    /// operands user and then uniques the list.
    ///
    /// *NOTE* The routine asserts that the passed in Users array is empty for
    /// simplicity. If needed this can be changed, but it is not necessary given
    /// current uses.
    mutating func getRCUsers(_ V: swift.SILValue, _ Users: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>)
    mutating func handleDeleteNotification(_ node: UnsafeMutablePointer<swift.SILNode>!)
  }

  /// SILFunction - A function body that has been lowered to SIL. This consists of
  /// zero or more SIL SILBasicBlock objects that contain the SILInstruction
  /// objects making up the function.
  struct SILFunction {
    enum Purpose : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8
      case None
      case GlobalInit
      case GlobalInitOnceFunction
      case LazyPropertyGetter
    }
    typealias iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift13SILBasicBlockELb1ELb0EvEELb0ELb0EEE
    typealias reverse_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift13SILBasicBlockELb1ELb0EvEELb1ELb0EEE
    typealias const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift13SILBasicBlockELb1ELb0EvEELb0ELb1EEE
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getLoweredType() -> swift.SILType
    mutating func getLoweredTypeInContext(_ context: swift.TypeExpansionContext) -> swift.SILType
    mutating func getConventions() -> swift.SILFunctionConventions
    mutating func getConventionsInContext() -> swift.SILFunctionConventions
    mutating func getProfiler() -> OpaquePointer!
    mutating func getDynamicallyReplacedFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func setDynamicallyReplacedFunction(_ f: UnsafeMutablePointer<swift.SILFunction>!)

    /// This function should only be called when SILFunctions are bulk deleted.
    mutating func dropDynamicallyReplacedFunction()
    mutating func hasObjCReplacement() -> Bool
    mutating func getObjCReplacement() -> swift.Identifier
    mutating func setObjCReplacement(_ replacedDecl: UnsafeMutablePointer<swift.AbstractFunctionDecl>!)
    mutating func setObjCReplacement(_ replacedDecl: swift.Identifier)
    mutating func setProfiler(_ InheritedProfiler: OpaquePointer!)
    mutating func createProfiler(_ Root: swift.ASTNode, _ forDecl: swift.SILDeclRef, _ forDefinition: swift.ForDefinition_t)
    mutating func discardProfiler()
    mutating func getEntryCount() -> swift.ProfileCounter
    mutating func setEntryCount(_ Count: swift.ProfileCounter)
    mutating func isNoReturnFunction(_ context: swift.TypeExpansionContext) -> Bool

    /// Return the number of entities referring to this function (other
    /// than the SILModule).
    mutating func getRefCount() -> UInt32

    /// Increment the reference count.
    mutating func incrementRefCount()

    /// Decrement the reference count.
    mutating func decrementRefCount()

    /// Drops all uses belonging to instructions in this function. The only valid
    /// operation performable on this object after this is called is called the
    /// destructor or deallocation.
    mutating func dropAllReferences()

    /// Notify that this function was inlined. This implies that it is still
    /// needed for debug info generation, even if it is removed afterwards.
    mutating func setInlined()

    /// Returns true if this function was inlined.
    mutating func isInlined() -> Bool

    /// Mark this function as removed from the module's function list, but kept
    /// as "zombie" for debug info or vtable stub generation.
    mutating func setZombie()

    /// Returns true if this function is dead, but kept in the module's zombie list.
    mutating func isZombie() -> Bool

    /// Returns true if this function has qualified ownership instructions in it.
    mutating func hasOwnership() -> Bool

    /// Sets the HasOwnership flag to false. This signals to SIL that no
    /// ownership instructions should be in this function any more.
    mutating func setOwnershipEliminated()

    /// Returns true if this function was deserialized from canonical
    /// SIL. (.swiftmodule files contain canonical SIL; .sib files may be 'raw'
    /// SIL). If so, diagnostics should not be reapplied.
    mutating func wasDeserializedCanonical() -> Bool
    mutating func setWasDeserializedCanonical(_ val: Bool)

    /// Returns true if this is a reabstraction thunk of escaping function type
    /// whose single argument is a potentially non-escaping closure. i.e. the
    /// thunks' function argument may itself have @inout_aliasable parameters.
    mutating func isWithoutActuallyEscapingThunk() -> Bool
    mutating func setWithoutActuallyEscapingThunk(_ val: Bool)
    mutating func isAsync() -> Bool

    /// Returns the calling convention used by this entry point.
    mutating func getRepresentation() -> swift.SILFunctionTypeRepresentation
    mutating func getResilienceExpansion() -> swift.ResilienceExpansion
    mutating func getTypeExpansionContext() -> swift.TypeExpansionContext
    mutating func getTypeLowering(_ orig: swift.Lowering.AbstractionPattern, _ subst: swift.`Type`) -> UnsafePointer<swift.Lowering.TypeLowering>
    mutating func getTypeLowering(_ t: swift.`Type`) -> UnsafePointer<swift.Lowering.TypeLowering>
    mutating func getLoweredType(_ orig: swift.Lowering.AbstractionPattern, _ subst: swift.`Type`) -> swift.SILType
    mutating func getLoweredType(_ t: swift.`Type`) -> swift.SILType
    mutating func getLoweredLoadableType(_ t: swift.`Type`) -> swift.SILType
    mutating func getLoweredType(_ t: swift.SILType) -> swift.SILType
    mutating func getTypeLowering(_ type: swift.SILType) -> UnsafePointer<swift.Lowering.TypeLowering>
    mutating func isTypeABIAccessible(_ type: swift.SILType) -> Bool

    /// Returns true if this function has a calling convention that has a self
    /// argument.
    mutating func hasSelfParam() -> Bool

    /// Returns true if the function has parameters that are consumed by the
    mutating func hasOwnedParameters() -> Bool
    mutating func hasIndirectFormalResults() -> Bool

    /// Returns true if this function ie either a class method, or a
    /// closure that captures the 'self' value or its metatype.
    ///
    /// If this returns true, DynamicSelfType can be used in the body
    /// of the function.
    ///
    /// Note that this is not the same as hasSelfParam().
    ///
    /// For closures that capture DynamicSelfType, hasDynamicSelfMetadata()
    /// is true and hasSelfParam() is false. For methods on value types,
    /// hasSelfParam() is true and hasDynamicSelfMetadata() is false.
    mutating func hasDynamicSelfMetadata() -> Bool

    /// Return the mangled name of this SILFunction.
    mutating func getName() -> llvm.StringRef

    /// A convenience function which checks if the function has a specific
    /// \p name. It is equivalent to getName() == Name, but as it is not
    /// inlined it can be called from the debugger.
    mutating func hasName(_ Name: UnsafePointer<CChar>!) -> Bool

    /// True if this is a declaration of a function defined in another module.
    mutating func isExternalDeclaration() -> Bool

    /// Returns true if this is a definition of a function defined in this module.
    mutating func isDefinition() -> Bool

    /// Returns true if there exist pre-specializations.
    mutating func hasPrespecialization() -> Bool

    /// Get this function's linkage attribute.
    mutating func getLinkage() -> swift.SILLinkage

    /// Set the function's linkage attribute.
    mutating func setLinkage(_ linkage: swift.SILLinkage)

    /// Returns true if this function can be inlined into a fragile function
    /// body.
    mutating func hasValidLinkageForFragileInline() -> Bool

    /// Returns true if this function can be referenced from a fragile function
    /// body.
    mutating func hasValidLinkageForFragileRef() -> Bool

    /// Get's the effective linkage which is used to derive the llvm linkage.
    /// Usually this is the same as getLinkage(), except in one case: if this
    /// function is a method in a class which has higher visibility than the
    /// method itself, the function can be referenced from vtables of derived
    /// classes in other compilation units.
    mutating func getEffectiveSymbolLinkage() -> swift.SILLinkage

    /// Helper method which returns true if this function has "external" linkage.
    mutating func isAvailableExternally() -> Bool

    /// Helper method which returns true if the linkage of the SILFunction
    /// indicates that the object's definition might be required outside the
    /// current SILModule.
    mutating func isPossiblyUsedExternally() -> Bool

    /// In addition to isPossiblyUsedExternally() it returns also true if this
    /// is a (private or internal) vtable method which can be referenced by
    /// vtables of derived classes outside the compilation unit.
    mutating func isExternallyUsedSymbol() -> Bool

    /// Return whether this function may be referenced by C code.
    mutating func hasCReferences() -> Bool
    mutating func setHasCReferences(_ value: Bool)

    /// Returns the availability context used to determine if the function's
    /// symbol should be weakly referenced across module boundaries.
    mutating func getAvailabilityForLinkage() -> swift.AvailabilityContext
    mutating func setAvailabilityForLinkage(_ availability: swift.AvailabilityContext)

    /// Returns whether this function's symbol must always be weakly referenced
    /// across module boundaries.
    mutating func isAlwaysWeakImported() -> Bool
    mutating func setAlwaysWeakImported(_ value: Bool)
    mutating func isWeakImported() -> Bool

    /// Returns whether this function implementation can be dynamically replaced.
    mutating func isDynamicallyReplaceable() -> swift.IsDynamicallyReplaceable_t
    mutating func setIsDynamic(_ value: swift.IsDynamicallyReplaceable_t)
    mutating func isExactSelfClass() -> swift.IsExactSelfClass_t
    mutating func setIsExactSelfClass(_ t: swift.IsExactSelfClass_t)

    /// Get the DeclContext of this function.
    mutating func getDeclContext() -> UnsafeMutablePointer<swift.DeclContext>!

    /// \returns True if the function is marked with the @_semantics attribute
    /// and has special semantics that the optimizer can use to optimize the
    /// function.
    mutating func hasSemanticsAttrs() -> Bool

    /// \returns True if the function has a semantic attribute that starts with a
    /// specific string.
    ///
    /// TODO: This needs a better name.
    mutating func hasSemanticsAttrThatStartsWith(_ S: llvm.StringRef) -> Bool

    /// \returns the semantics tag that describes this function.
    mutating func getSemanticsAttrs() -> llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE

    /// \returns True if the function has the semantics flag \p Value;
    mutating func hasSemanticsAttr(_ Value: llvm.StringRef) -> Bool

    /// Add the given semantics attribute to the attr list set.
    mutating func addSemanticsAttr(_ Ref: llvm.StringRef)

    /// Remove the semantics
    mutating func removeSemanticsAttr(_ Ref: llvm.StringRef)

    /// \returns the range of specialize attributes.
    mutating func getSpecializeAttrs() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift17SILSpecializeAttrEEE

    /// Removes all specialize attributes from this function.
    mutating func clearSpecializeAttrs()
    mutating func addSpecializeAttr(_ Attr: UnsafeMutablePointer<swift.SILSpecializeAttr>!)
    mutating func removeSpecializeAttr(_ attr: UnsafeMutablePointer<swift.SILSpecializeAttr>!)
    mutating func forEachSpecializeAttrTargetFunction(_ action: llvm.__CxxTemplateInstN4llvm12function_refIFvPN5swift11SILFunctionEEEE)

    /// Get this function's optimization mode or OptimizationMode::NotSet if it is
    /// not set for this specific function.
    mutating func getOptimizationMode() -> swift.OptimizationMode

    /// Returns the optimization mode for the function. If no mode is set for the
    /// function, returns the global mode, i.e. the mode of the module's options.
    mutating func getEffectiveOptimizationMode() -> swift.OptimizationMode
    mutating func setOptimizationMode(_ mode: swift.OptimizationMode)

    /// \returns True if the function is optimizable (i.e. not marked as no-opt),
    ///          or is raw SIL (so that the mandatory passes still run).
    mutating func shouldOptimize() -> Bool

    /// Returns true if this function should be optimized for size.
    mutating func optimizeForSize() -> Bool

    /// Returns true if this is a function that should have its ownership
    /// verified.
    mutating func shouldVerifyOwnership() -> Bool

    /// Check if the function has a location.
    /// FIXME: All functions should have locations, so this method should not be
    /// necessary.
    mutating func hasLocation() -> Bool

    /// Get the source location of the function.
    mutating func getLocation() -> swift.SILLocation

    /// Initialize the debug scope of the function and also set the DeclCtxt.
    mutating func setDebugScope(_ DS: UnsafePointer<swift.SILDebugScope>!)

    /// Initialize the debug scope for debug info on SIL level (-gsil).
    mutating func setSILDebugScope(_ DS: UnsafePointer<swift.SILDebugScope>!)

    /// Get the source location of the function.
    mutating func getDebugScope() -> UnsafePointer<swift.SILDebugScope>!

    /// Get this function's bare attribute.
    mutating func isBare() -> swift.IsBare_t
    mutating func setBare(_ isB: swift.IsBare_t)

    /// Get this function's transparent attribute.
    mutating func isTransparent() -> swift.IsTransparent_t
    mutating func setTransparent(_ isT: swift.IsTransparent_t)

    /// Get this function's serialized attribute.
    mutating func isSerialized() -> swift.IsSerialized_t
    mutating func setSerialized(_ isSerialized: swift.IsSerialized_t)

    /// Get this function's thunk attribute.
    mutating func isThunk() -> swift.IsThunk_t
    mutating func setThunk(_ isThunk: swift.IsThunk_t)

    /// Get the class visibility (relevant for class methods).
    mutating func getClassSubclassScope() -> swift.SubclassScope
    mutating func setClassSubclassScope(_ scope: swift.SubclassScope)

    /// Get this function's noinline attribute.
    mutating func getInlineStrategy() -> swift.Inline_t
    mutating func setInlineStrategy(_ inStr: swift.Inline_t)

    /// \return the function side effects information.
    mutating func getEffectsKind() -> swift.EffectsKind

    /// \return True if the function is annotated with the @_effects attribute.
    mutating func hasEffectsKind() -> Bool

    /// Set the function side effect information.
    mutating func setEffectsKind(_ E: swift.EffectsKind)
    mutating func getSpecialPurpose() -> swift.SILFunction.Purpose

    /// Get this function's global_init attribute.
    ///
    /// The implied semantics are:
    /// - side-effects can occur any time before the first invocation.
    /// - all calls to the same global_init function have the same side-effects.
    /// - any operation that may observe the initializer's side-effects must be
    ///   preceded by a call to the initializer.
    ///
    /// This is currently true if the function is an addressor that was lazily
    /// generated from a global variable access. Note that the initialization
    /// function itself does not need this attribute. It is private and only
    /// called within the addressor.
    mutating func isGlobalInit() -> Bool
    mutating func isGlobalInitOnceFunction() -> Bool
    mutating func isLazyPropertyGetter() -> Bool
    mutating func setSpecialPurpose(_ purpose: swift.SILFunction.Purpose)

    /// Return whether this function has a foreign implementation which can
    /// be emitted on demand.
    mutating func hasForeignBody() -> Bool

    /// Return whether this function corresponds to a Clang node.
    mutating func hasClangNode() -> Bool

    /// Set the owning declaration of the Clang node associated with this
    /// function.  We have to store an owner (a Swift declaration) instead of
    /// directly referencing the original declaration due to current
    /// limitations in the serializer.
    mutating func setClangNodeOwner(_ owner: UnsafeMutablePointer<swift.ValueDecl>!)

    /// Return the owning declaration of the Clang node associated with this
    /// function.  This should only be used for serialization.
    mutating func getClangNodeOwner() -> UnsafeMutablePointer<swift.ValueDecl>!

    /// Return the Clang node associated with this function if it has one.
    mutating func getClangNode() -> swift.ClangNode
    mutating func getClangDecl() -> UnsafePointer<clang.Decl>!

    /// Returns whether this function is a specialization.
    mutating func isSpecialization() -> Bool

    /// Return the specialization information.
    mutating func getSpecializationInfo() -> UnsafePointer<swift.GenericSpecializationInformation>!
    mutating func setSpecializationInfo(_ Info: UnsafePointer<swift.GenericSpecializationInformation>!)

    /// If this function is a specialization, return the original function from
    /// which this function was specialized.
    mutating func getOriginOfSpecialization() -> UnsafePointer<swift.SILFunction>!

    /// Retrieve the generic environment containing the mapping from interface
    /// types to context archetypes for this function. Only present if the
    /// function has a body.
    mutating func getGenericEnvironment() -> OpaquePointer!
    mutating func setGenericEnvironment(_ env: OpaquePointer!)

    /// Map the given type, which is based on an interface SILFunctionType and may
    /// therefore be dependent, to a type based on the context archetypes of this
    /// SILFunction.
    mutating func mapTypeIntoContext(_ type: swift.`Type`) -> swift.`Type`

    /// Map the given type, which is based on an interface SILFunctionType and may
    /// therefore be dependent, to a type based on the context archetypes of this
    /// SILFunction.
    mutating func mapTypeIntoContext(_ type: swift.SILType) -> swift.SILType

    /// Converts the given function definition to a declaration.
    mutating func convertToDeclaration()

    /// Return the identity substitutions necessary to forward this call if it is
    /// generic.
    mutating func getForwardingSubstitutionMap() -> swift.SubstitutionMap
    mutating func empty() -> Bool
    mutating func begin() -> swift.SILFunction.iterator
    mutating func end() -> swift.SILFunction.iterator
    mutating func rbegin() -> swift.SILFunction.reverse_iterator
    mutating func rend() -> swift.SILFunction.reverse_iterator
    mutating func begin() -> swift.SILFunction.const_iterator
    mutating func end() -> swift.SILFunction.const_iterator
    mutating func size() -> UInt32
    mutating func front() -> UnsafeMutablePointer<swift.SILBasicBlock>
    mutating func front() -> UnsafePointer<swift.SILBasicBlock>
    mutating func getEntryBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getEntryBlock() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func createBasicBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func createBasicBlockAfter(_ afterBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func createBasicBlockBefore(_ beforeBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Splice the body of \p F into this function at end.
    mutating func spliceBody(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Return the unique basic block containing a return inst if it
    /// exists. Otherwise, returns end.
    mutating func findReturnBB() -> swift.SILFunction.iterator

    /// Return the unique basic block containing a return inst if it
    /// exists. Otherwise, returns end.
    mutating func findReturnBB() -> swift.SILFunction.const_iterator

    /// Return the unique basic block containing a throw inst if it
    /// exists. Otherwise, returns end.
    mutating func findThrowBB() -> swift.SILFunction.iterator

    /// Return the unique basic block containing a throw inst if it
    /// exists. Otherwise, returns end.
    mutating func findThrowBB() -> swift.SILFunction.const_iterator

    /// Loop over all blocks in this function and add all function exiting blocks
    /// to output.
    mutating func findExitingBlocks(_ output: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift13SILBasicBlockEEE>)
    mutating func getArgument(_ i: UInt32) -> UnsafeMutablePointer<swift.SILArgument>!
    mutating func getArgument(_ i: UInt32) -> UnsafePointer<swift.SILArgument>!
    mutating func getArguments() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift11SILArgumentEEE
    mutating func getIndirectResults() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift11SILArgumentEEE
    mutating func getArgumentsWithoutIndirectResults() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift11SILArgumentEEE
    mutating func getSelfArgument() -> UnsafePointer<swift.SILArgument>!
    mutating func getDynamicSelfMetadata() -> UnsafePointer<swift.SILArgument>!

    /// verify - Run the IR verifier to make sure that the SILFunction follows
    /// invariants.
    mutating func verify(_ SingleFunction: Bool)

    /// Run the SIL ownership verifier to check for ownership invariant failures.
    ///
    /// NOTE: The ownership verifier is always run when performing normal IR
    /// verification, so this verification can be viewed as a subset of
    /// SILFunction::verify.
    mutating func verifyOwnership(_ deadEndBlocks: OpaquePointer!)

    /// Verify that all non-cond-br critical edges have been split.
    ///
    /// This is a fast subset of the checks performed in the SILVerifier.
    mutating func verifyCriticalEdges()

    /// Pretty-print the SILFunction.
    mutating func dump(_ Verbose: Bool)
    mutating func dump()

    /// Pretty-print the SILFunction.
    /// Useful for dumping the function when running in a debugger.
    /// Warning: no error handling is done. Fails with an assert if the file
    /// cannot be opened.
    mutating func dump(_ FileName: UnsafePointer<CChar>!)

    /// Pretty-print the SILFunction to the tream \p OS.
    ///
    /// \param Verbose Dump SIL location information in verbose mode.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool)

    /// Pretty-print the SILFunction with the context \p PrintCtx.
    @warn_unqualified_access
    mutating func print(_ PrintCtx: UnsafeMutablePointer<swift.SILPrintContext>)

    /// Pretty-print the SILFunction's name using SIL syntax,
    /// '@function_mangled_name'.
    mutating func printName(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)

    /// Assigns consecutive numbers to all the SILNodes in the function.
    /// For instructions, both the instruction node and the value nodes of
    /// any results will be assigned numbers; the instruction node will
    /// be numbered the same as the first result, if there are any results.
    mutating func numberValues(_ nodeToNumberMap: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm8DenseMapIPKN5swift7SILNodeEjNS_12DenseMapInfoIS4_EENS_6detail12DenseMapPairIS4_jEEEE>)
    mutating func getASTContext() -> UnsafeMutablePointer<swift.ASTContext>

    /// This function is meant for use from the debugger.  You can just say 'call
    /// F->viewCFG()' and a ghostview window should pop up from the program,
    /// displaying the CFG of the current function with the code for each basic
    /// block inside.  This depends on there being a 'dot' and 'gv' program in
    /// your path.
    mutating func viewCFG()

    /// Like ViewCFG, but the graph does not show the contents of basic blocks.
    mutating func viewCFGOnly()
  }

  /// Limit the size of the rc identity cache. We keep a cache per function.
  static let MaxRCIdentityCacheSize: UInt32
  struct DominanceAnalysis {
    init()
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
    mutating func newFunctionAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift13DominanceInfoENS_14default_deleteIS2_EEEE
    mutating func shouldInvalidate(_ K: swift.SILAnalysis.InvalidationKind) -> Bool
  }
  struct PostDominanceAnalysis {
    init()
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
    mutating func newFunctionAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift17PostDominanceInfoENS_14default_deleteIS2_EEEE
    mutating func shouldInvalidate(_ K: swift.SILAnalysis.InvalidationKind) -> Bool
  }

  /// Helper class for visiting basic blocks in dominance order, based on a
  /// worklist algorithm. Example usage:
  /// \code
  ///   DominanceOrder DomOrder(Function->front(), DominanceInfo);
  ///   while (SILBasicBlock *block = DomOrder.getNext()) {
  ///     doSomething(block);
  ///     domOrder.pushChildren(block);
  ///   }
  /// \endcode
  struct DominanceOrder {

    /// Constructor.
    /// \p entry The root of the dominator (sub-)tree.
    /// \p DT The dominance info of the function.
    /// \p capacity Should be the number of basic blocks in the dominator tree to
    ///             reduce memory allocation.
    init(_ root: UnsafeMutablePointer<swift.SILBasicBlock>!, _ DT: UnsafeMutablePointer<swift.DominanceInfo>!, _ capacity: Int32)

    /// Gets the next block from the worklist.
    ///
    mutating func getNext() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Pushes the dominator children of a block onto the worklist.
    mutating func pushChildren(_ block: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Conditionally pushes the dominator children of a block onto the worklist.
    /// \p pred Takes a block (= a dominator child) as argument and returns true
    ///         if it should be added to the worklist.
    ///
    mutating func pushChildrenIf<Pred>(_ block: UnsafeMutablePointer<swift.SILBasicBlock>!, _ pred: Pred)
  }

  /// A class for computing basic post-dominance information.
  struct PostDominanceInfo {
    init(_ F: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func properlyDominates(_ A: UnsafeMutablePointer<swift.SILInstruction>!, _ B: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool
    mutating func properlyDominates(_ A: swift.SILValue, _ B: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool
    mutating func verify()

    /// Return true if the other dominator tree does not match this dominator
    /// tree.
    mutating func errorOccurredOnComparison(_ Other: UnsafePointer<swift.PostDominanceInfo>) -> Bool
    mutating func isValid(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> Bool
  }
  struct SILBasicBlock {
    typealias iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift14SILInstructionELb1ELb0EvEELb0ELb0EEE
    typealias const_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift14SILInstructionELb1ELb0EvEELb0ELb1EEE
    typealias reverse_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift14SILInstructionELb1ELb0EvEELb1ELb0EEE
    typealias const_reverse_iterator = llvm.__CxxTemplateInstN4llvm14ilist_iteratorINS_12ilist_detail12node_optionsIN5swift14SILInstructionELb1ELb0EvEELb1ELb1EEE
    typealias arg_iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift11SILArgumentENS_9allocatorIS3_EEEE.iterator
    typealias const_arg_iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift11SILArgumentENS_9allocatorIS3_EEEE.const_iterator
    typealias phi_iterator = swift.SILBasicBlock.__CxxTemplateInstN5swift13SILBasicBlock17phi_iterator_implINS_14SILPhiArgumentENSt3__111__wrap_iterIPPNS_11SILArgumentEEEEE
    typealias const_phi_iterator = swift.SILBasicBlock.__CxxTemplateInstN5swift13SILBasicBlock17phi_iterator_implIKNS_14SILPhiArgumentENSt3__111__wrap_iterIPKPNS_11SILArgumentEEEEE
    typealias SuccessorListTy = swift.TermInst.SuccessorListTy
    typealias ConstSuccessorListTy = swift.TermInst.ConstSuccessorListTy
    typealias const_succ_iterator = swift.TermInst.const_succ_iterator
    typealias succ_iterator = swift.TermInst.succ_iterator
    typealias succblock_iterator = swift.TermInst.succblock_iterator
    typealias const_succblock_iterator = swift.TermInst.const_succblock_iterator
    typealias SuccessorBlockListTy = swift.TermInst.SuccessorBlockListTy
    typealias ConstSuccessorBlockListTy = swift.TermInst.ConstSuccessorBlockListTy
    typealias pred_iterator = swift.SILSuccessor.pred_iterator

    /// Gets the ID (= index in the function's block list) of the block.
    ///
    /// Returns -1 if the block is not contained in a function.
    /// Warning: This function is slow. Therefore it should only be used for
    ///          debug output.
    mutating func getDebugID() -> Int32
    mutating func getParent() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getParent() -> UnsafePointer<swift.SILFunction>!
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>

    /// This method unlinks 'self' from the containing SILFunction and deletes it.
    mutating func eraseFromParent()

    /// Remove all instructions of a SILGlobalVariable's static initializer block.
    mutating func clearStaticInitializerBlock(_ module: UnsafeMutablePointer<swift.SILModule>)
    mutating func insert(_ InsertPt: swift.SILBasicBlock.iterator, _ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func insert(_ InsertPt: UnsafeMutablePointer<swift.SILInstruction>!, _ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func push_back(_ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func push_front(_ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func remove(_ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func erase(_ I: UnsafeMutablePointer<swift.SILInstruction>!) -> swift.SILBasicBlock.iterator
    mutating func back() -> UnsafeMutablePointer<swift.SILInstruction>
    mutating func back() -> UnsafePointer<swift.SILInstruction>
    mutating func front() -> UnsafeMutablePointer<swift.SILInstruction>
    mutating func front() -> UnsafePointer<swift.SILInstruction>

    /// Transfer the instructions from Other to the end of this block.
    mutating func spliceAtEnd(_ Other: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func spliceAtBegin(_ Other: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func empty() -> Bool
    mutating func begin() -> swift.SILBasicBlock.iterator
    mutating func end() -> swift.SILBasicBlock.iterator
    mutating func begin() -> swift.SILBasicBlock.const_iterator
    mutating func end() -> swift.SILBasicBlock.const_iterator
    mutating func rbegin() -> swift.SILBasicBlock.reverse_iterator
    mutating func rend() -> swift.SILBasicBlock.reverse_iterator
    mutating func rbegin() -> swift.SILBasicBlock.const_reverse_iterator
    mutating func rend() -> swift.SILBasicBlock.const_reverse_iterator
    mutating func getTerminator() -> UnsafeMutablePointer<swift.TermInst>!
    mutating func getTerminator() -> UnsafePointer<swift.TermInst>!

    /// Splits a basic block into two at the specified instruction.
    ///
    /// Note that all the instructions BEFORE the specified iterator
    /// stay as part of the original basic block. The old basic block is left
    /// without a terminator.
    mutating func split(_ I: swift.SILBasicBlock.iterator) -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Move the basic block to after the specified basic block in the IR.
    ///
    /// Assumes that the basic blocks must reside in the same function. In asserts
    /// builds, an assert verifies that this is true.
    mutating func moveAfter(_ After: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Moves the instruction to the iterator in this basic block.
    mutating func moveTo(_ To: swift.SILBasicBlock.iterator, _ I: UnsafeMutablePointer<swift.SILInstruction>!)
    mutating func args_empty() -> Bool
    mutating func args_size() -> Int
    mutating func args_begin() -> swift.SILBasicBlock.arg_iterator
    mutating func args_end() -> swift.SILBasicBlock.arg_iterator
    mutating func args_begin() -> swift.SILBasicBlock.const_arg_iterator
    mutating func args_end() -> swift.SILBasicBlock.const_arg_iterator
    mutating func phis() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift13SILBasicBlock17phi_iterator_implINS1_14SILPhiArgumentENSt3__111__wrap_iterIPPNS1_11SILArgumentEEEEEEE
    mutating func phis() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift13SILBasicBlock17phi_iterator_implIKNS1_14SILPhiArgumentENSt3__111__wrap_iterIPKPNS1_11SILArgumentEEEEEEE
    mutating func getArguments() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift11SILArgumentEEE
    mutating func getNumArguments() -> UInt32
    mutating func getArgument(_ i: UInt32) -> UnsafePointer<swift.SILArgument>!
    mutating func getArgument(_ i: UInt32) -> UnsafeMutablePointer<swift.SILArgument>!
    mutating func cloneArgumentList(_ Other: UnsafeMutablePointer<swift.SILBasicBlock>!)
    mutating func moveArgumentList(_ from: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Erase a specific argument from the arg list.
    mutating func eraseArgument(_ Index: Int32)

    /// Allocate a new argument of type \p Ty and append it to the argument
    /// list. Optionally you can pass in a value decl parameter.
    mutating func createFunctionArgument(_ Ty: swift.SILType, _ D: UnsafePointer<swift.ValueDecl>!, _ disableEntryBlockVerification: Bool) -> UnsafeMutablePointer<swift.SILFunctionArgument>!
    mutating func insertFunctionArgument(_ Index: UInt32, _ Ty: swift.SILType, _ OwnershipKind: swift.ValueOwnershipKind, _ D: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILFunctionArgument>!

    /// Replace the \p{i}th Function arg with a new Function arg with SILType \p
    /// Ty and ValueDecl \p D.
    mutating func replaceFunctionArgument(_ i: UInt32, _ Ty: swift.SILType, _ Kind: swift.ValueOwnershipKind, _ D: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILFunctionArgument>!

    /// Replace the \p{i}th BB arg with a new BBArg with SILType \p Ty and
    /// ValueDecl \p D.
    ///
    /// NOTE: This assumes that the current argument in position \p i has had its
    /// uses eliminated. To replace/replace all uses with, use
    /// replacePhiArgumentAndRAUW.
    mutating func replacePhiArgument(_ i: UInt32, _ type: swift.SILType, _ kind: swift.ValueOwnershipKind, _ decl: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!

    /// Replace phi argument \p i and RAUW all uses.
    mutating func replacePhiArgumentAndReplaceAllUses(_ i: UInt32, _ type: swift.SILType, _ kind: swift.ValueOwnershipKind, _ decl: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!

    /// Allocate a new argument of type \p Ty and append it to the argument
    /// list. Optionally you can pass in a value decl parameter.
    mutating func createPhiArgument(_ Ty: swift.SILType, _ Kind: swift.ValueOwnershipKind, _ D: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!

    /// Insert a new SILPhiArgument with type \p Ty and \p Decl at position \p
    /// Pos.
    mutating func insertPhiArgument(_ Pos: swift.SILBasicBlock.arg_iterator, _ Ty: swift.SILType, _ Kind: swift.ValueOwnershipKind, _ D: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!
    mutating func insertPhiArgument(_ Index: UInt32, _ Ty: swift.SILType, _ Kind: swift.ValueOwnershipKind, _ D: UnsafePointer<swift.ValueDecl>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!

    /// Remove all block arguments.
    mutating func dropAllArguments()

    /// The successors of a SILBasicBlock are defined either explicitly as
    /// a single successor as the branch targets of the terminator instruction.
    mutating func getSuccessors() -> swift.SILBasicBlock.ConstSuccessorListTy
    mutating func getSuccessors() -> swift.SILBasicBlock.SuccessorListTy
    mutating func succ_empty() -> Bool
    mutating func succ_begin() -> swift.SILBasicBlock.succ_iterator!
    mutating func succ_end() -> swift.SILBasicBlock.succ_iterator!
    mutating func succ_begin() -> swift.SILBasicBlock.const_succ_iterator!
    mutating func succ_end() -> swift.SILBasicBlock.const_succ_iterator!
    mutating func succblock_begin() -> swift.SILBasicBlock.succblock_iterator
    mutating func succblock_end() -> swift.SILBasicBlock.succblock_iterator
    mutating func succblock_begin() -> swift.SILBasicBlock.const_succblock_iterator
    mutating func succblock_end() -> swift.SILBasicBlock.const_succblock_iterator
    mutating func getSingleSuccessorBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSingleSuccessorBlock() -> UnsafePointer<swift.SILBasicBlock>!

    /// Returns true if \p BB is a successor of this block.
    mutating func isSuccessorBlock(_ Block: UnsafeMutablePointer<swift.SILBasicBlock>!) -> Bool

    /// Return the range of SILBasicBlocks that are successors of this block.
    mutating func getSuccessorBlocks() -> swift.SILBasicBlock.SuccessorBlockListTy

    /// Return the range of SILBasicBlocks that are successors of this block.
    mutating func getSuccessorBlocks() -> swift.SILBasicBlock.ConstSuccessorBlockListTy
    mutating func pred_empty() -> Bool
    mutating func pred_begin() -> swift.SILBasicBlock.pred_iterator
    mutating func pred_end() -> swift.SILBasicBlock.pred_iterator
    mutating func getPredecessorBlocks() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift12SILSuccessor13pred_iteratorEEE
    mutating func isPredecessorBlock(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> Bool
    mutating func getSinglePredecessorBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSinglePredecessorBlock() -> UnsafePointer<swift.SILBasicBlock>!

    /// Returns true if this BB is the entry BB of its parent.
    mutating func isEntry() -> Bool

    /// Returns true if this block ends in an unreachable or an apply of a
    /// no-return apply or builtin.
    mutating func isNoReturn() -> Bool

    /// Returns true if this block only contains a branch instruction.
    mutating func isTrampoline() -> Bool

    /// Returns true if it is legal to hoist instructions into this block.
    ///
    /// Used by llvm::LoopInfo.
    mutating func isLegalToHoistInto() -> Bool

    /// Returns the debug scope of the first non-meta instructions in the
    /// basic block. SILBuilderWithScope uses this to correctly set up
    /// the debug scope for newly created instructions.
    mutating func getScopeOfFirstNonMetaInstruction() -> UnsafePointer<swift.SILDebugScope>!

    /// Pretty-print the SILBasicBlock.
    mutating func dump()

    /// Pretty-print the SILBasicBlock with the designated stream.
    @warn_unqualified_access
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)

    /// Pretty-print the SILBasicBlock with the designated context.
    @warn_unqualified_access
    mutating func print(_ Ctx: UnsafeMutablePointer<swift.SILPrintContext>)
    mutating func printAsOperand(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ PrintType: Bool)

    /// Drops all uses that belong to this basic block.
    mutating func dropAllReferences()
    mutating func eraseInstructions()
  }
  struct PostOrderFunctionInfo {
    typealias iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift13SILBasicBlockENS_9allocatorIS3_EEEE.iterator
    typealias const_iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift13SILBasicBlockENS_9allocatorIS3_EEEE.const_iterator
    typealias reverse_iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift13SILBasicBlockENS_9allocatorIS3_EEEE.reverse_iterator
    typealias const_reverse_iterator = std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift13SILBasicBlockENS_9allocatorIS3_EEEE.const_reverse_iterator
    typealias range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPPN5swift13SILBasicBlockEEEEE
    typealias const_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPKPN5swift13SILBasicBlockEEEEE
    typealias reverse_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__116reverse_iteratorINS1_11__wrap_iterIPPN5swift13SILBasicBlockEEEEEEE
    typealias const_reverse_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__116reverse_iteratorINS1_11__wrap_iterIPKPN5swift13SILBasicBlockEEEEEEE
    init(_ F: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func getPostOrder() -> swift.PostOrderFunctionInfo.range
    mutating func getPostOrder() -> swift.PostOrderFunctionInfo.const_range
    mutating func getReversePostOrder() -> swift.PostOrderFunctionInfo.reverse_range
    mutating func getReversePostOrder() -> swift.PostOrderFunctionInfo.const_reverse_range
    mutating func getReversePostOrder(_ StartBlock: UnsafeMutablePointer<swift.SILBasicBlock>!) -> swift.PostOrderFunctionInfo.const_reverse_range
    mutating func getReversePostOrder(_ RPONumber: UInt32) -> swift.PostOrderFunctionInfo.const_reverse_range
    mutating func size() -> UInt32
    mutating func getPONumber(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE
    mutating func getRPONumber(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE
  }

  /// This is the base class of the SIL value hierarchy, which represents a
  /// runtime computed value. Some examples of ValueBase are SILArgument and
  /// SingleValueInstruction.
  struct ValueBase {
    typealias use_iterator = swift.ValueBaseUseIterator
    typealias use_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift20ValueBaseUseIteratorEEE
    typealias consuming_use_iterator = swift.ConsumingUseIterator
    typealias consuming_use_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift20ConsumingUseIteratorEEE
    typealias non_consuming_use_iterator = swift.NonConsumingUseIterator
    typealias non_consuming_use_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift23NonConsumingUseIteratorEEE
    struct DefiningInstructionResult {
      var Instruction: UnsafeMutablePointer<swift.SILInstruction>!
      var ResultIndex: Int
      init()
      init(Instruction: UnsafeMutablePointer<swift.SILInstruction>!, ResultIndex: Int)
    }
    mutating func getKind() -> swift.ValueKind
    mutating func getType() -> swift.SILType

    /// Replace every use of a result of this instruction with the corresponding
    /// result from RHS.
    ///
    /// The method assumes that both instructions have the same number of
    /// results. To replace just one result use SILValue::replaceAllUsesWith.
    mutating func replaceAllUsesWith(_ RHS: UnsafeMutablePointer<swift.ValueBase>!)

    /// Replace all uses of this instruction with an undef value of the
    /// same type as the result of this instruction.
    mutating func replaceAllUsesWithUndef()

    /// Is this value a direct result of the given instruction?
    mutating func isResultOf(_ I: UnsafeMutablePointer<swift.SILInstruction>!) -> Bool

    /// Returns true if this value has no uses.
    /// To ignore debug-info instructions use swift::onlyHaveDebugUses instead
    /// (see comment in DebugUtils.h).
    mutating func use_empty() -> Bool
    mutating func use_begin() -> swift.ValueBase.use_iterator
    mutating func use_end() -> swift.ValueBase.use_iterator
    mutating func consuming_use_begin() -> swift.ValueBase.consuming_use_iterator
    mutating func consuming_use_end() -> swift.ValueBase.consuming_use_iterator
    mutating func non_consuming_use_begin() -> swift.ValueBase.non_consuming_use_iterator
    mutating func non_consuming_use_end() -> swift.ValueBase.non_consuming_use_iterator

    /// Returns a range of all uses, which is useful for iterating over all uses.
    /// To ignore debug-info instructions use swift::getNonDebugUses instead
    /// (see comment in DebugUtils.h).
    mutating func getUses() -> swift.ValueBase.use_range

    /// Returns true if this value has exactly one use.
    /// To ignore debug-info instructions use swift::hasOneNonDebugUse instead
    /// (see comment in DebugUtils.h).
    mutating func hasOneUse() -> Bool

    /// Returns .some(single user) if this value has a single user. Returns .none
    /// otherwise.
    mutating func getSingleUse() -> UnsafeMutablePointer<swift.Operand>!

    /// Returns .some(single user) if this value is non-trivial, we are in ossa,
    /// and it has a single consuming user. Returns .none otherwise.
    mutating func getSingleConsumingUse() -> UnsafeMutablePointer<swift.Operand>!

    /// Returns a range of all consuming uses
    mutating func getConsumingUses() -> swift.ValueBase.consuming_use_range

    /// Returns a range of all non consuming uses
    mutating func getNonConsumingUses() -> swift.ValueBase.non_consuming_use_range
    mutating func getSingleUserOfType<T>() -> OpaquePointer!
    mutating func getSingleConsumingUserOfType<T>() -> OpaquePointer!

    /// Returns true if this operand has exactly two.
    ///
    /// This is useful if one has found a predefined set of 2 unique users and
    /// wants to check if there are any other users without iterating over the
    /// entire use list.
    mutating func hasTwoUses() -> Bool

    /// Return the instruction that defines this value, or null if it is
    /// not defined by an instruction.
    mutating func getDefiningInstruction() -> UnsafePointer<swift.SILInstruction>!
    mutating func getDefiningInstruction() -> UnsafeMutablePointer<swift.SILInstruction>!

    /// Return the SIL instruction that can be used to describe the first time
    /// this value is available.
    ///
    /// For instruction results, this returns getDefiningInstruction(). For
    /// arguments, this returns SILBasicBlock::begin() for the argument's parent
    /// block. Returns nullptr for SILUndef.
    mutating func getDefiningInsertionPoint() -> UnsafePointer<swift.SILInstruction>!
    mutating func getDefiningInsertionPoint() -> UnsafeMutablePointer<swift.SILInstruction>!
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ V: UnsafePointer<swift.ValueBase>!) -> Bool
  }

  /// The SideEffectAnalysis provides information about side-effects of SIL
  /// functions. Side-effect information is provided per function and includes:
  /// Does the function read or write memory? Does the function retain or release
  /// objects? etc.
  /// For details see FunctionSideEffects.
  struct SideEffectAnalysis {
    init()
    static func classof(_ S: UnsafePointer<swift.SILAnalysis>!) -> Bool
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, R: swift.AliasAnalysis.AliasResult) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// If this value is an address that obeys strict TBAA, return the address type.
  /// Otherwise, return an empty type.
  static func computeTBAAType(_ V: swift.SILValue) -> swift.SILType

  /// An enum to represent the kind of scan we perform when we calculate
  /// side effects.
  enum RetainObserveKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case ObserveRetains
    case IgnoreRetains
    case RetainObserveKindEnd
  }

  /// Generic base class for any bottom up analysis that summarizes per-function
  /// "effects" by first computing local effects, then propagating those effects
  /// bottom-up through the call graph.
  ///
  /// FunctionEffects constraints:
  /// - void clear()
  /// - void setWorstEffects()
  /// - bool summarizeFunction(SILFunction *)
  /// - bool summarizeCall(FullApplySite)
  /// - bool mergeFrom(const FunctionSideEffects &)
  /// - bool mergeFromApply(const FunctionEffects &, FullApplySite)
  /// - void analyzeInstruction(SILInstruction *)
  struct __CxxTemplateInstN5swift29GenericFunctionEffectAnalysisINS_19FunctionSideEffectsEEE {
    init(_ kind: swift.SILAnalysisKind)
    mutating func getEffects(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafePointer<swift.FunctionSideEffects>

    /// Get the merged effects of all callees at the given call site from the
    /// callee's perspective (don't transform parameter effects).
    mutating func getCalleeEffects(_ calleeEffects: UnsafeMutablePointer<swift.FunctionSideEffects>, _ fullApply: swift.FullApplySite)

    /// Get the merge effects of all callees at the given call site from the
    /// caller's perspective. Parameter effects are translated into information
    /// for the caller's arguments, and local effects are dropped.
    mutating func getCallSiteEffects(_ callEffects: UnsafeMutablePointer<swift.FunctionSideEffects>, _ fullApply: swift.FullApplySite)
    mutating func initialize(_ PM: UnsafeMutablePointer<swift.SILPassManager>!)

    /// Invalidate all information in this analysis.
    mutating func invalidate()

    /// Invalidate all of the information for a specific function.
    mutating func invalidate(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ K: swift.SILAnalysis.InvalidationKind)

    /// Notify the analysis about a newly created function.
    mutating func notifyAddedOrModifiedFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the analysis about a function which will be deleted from the
    /// module.
    mutating func notifyWillDeleteFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the analysis about changed witness or vtables.
    mutating func invalidateFunctionTables()
  }

  /// Set \p dest if \p src is set and return true if \p dest was not set
  /// before.
  static func changedFlagByInPlaceOr(_ dest: UnsafeMutablePointer<Bool>, _ src: Bool) -> Bool

  /// Side-effect information for the function (global effects) or a specific
  /// parameter of the function. See FunctionSideEffects.
  struct FunctionSideEffectFlags {
    init()

    /// Does the function read from memory (excluding reads from locally
    /// allocated memory)?
    mutating func mayRead() -> Bool

    /// Does the function write to memory (excluding writes to locally
    /// allocated memory)?
    mutating func mayWrite() -> Bool

    /// Does the function retain objects (excluding retains of locally
    /// allocated objects)?
    mutating func mayRetain() -> Bool

    /// Does the function release objects (excluding releases of locally
    /// allocated objects)?
    mutating func mayRelease() -> Bool

    /// Gets the memory behavior considering the global effects and
    /// all parameter effects. If \p ScanKind equals ignoreRetains then retain
    /// instructions are considered as side effects.
    mutating func getMemBehavior(_ ScanKind: swift.RetainObserveKind) -> swift.SILInstruction.MemoryBehavior

    /// Merge effects from \p RHS.
    mutating func mergeFrom(_ RHS: UnsafePointer<swift.FunctionSideEffectFlags>) -> Bool
  }

  /// Summarizes the side-effects of a function. The side-effect information
  /// is divided into global effects and effects for specific function
  /// parameters.
  /// If a side-effect can be associated to a specific function parameter, it is
  /// not added to the global effects of the function. E.g. if a memory write is
  /// only done through an @inout parameter, the mayWrite side-effect is only
  /// accounted for this parameter.
  /// Effects for a parameter make only sense if the parameter is implemented as
  /// a pointer or contains a pointer:
  /// *) The parameter is an address parameter, e.g. @out, @inout, etc.
  /// *) The parameter is a reference
  /// *) The parameter is a value type (e.g. struct) and contains a reference.
  ///    In this case the effects refer to all references in the value type.
  ///    E.g. if a struct contains 2 references, a mayWrite effect means that
  ///    memory is written to one of the referenced objects (or to both).
  struct FunctionSideEffects {

    /// Constructs "empty" function effects. This effects object can later be
    /// populated by summarizeFunction or summarizeCall.
    init()

    /// Sets the most conservative effects, if we don't know anything about the
    /// function.
    mutating func setWorstEffects()

    /// Clears all effects.
    mutating func clear()

    /// Merge the flags from \p RHS.
    mutating func mergeFlags(_ RHS: UnsafePointer<swift.FunctionSideEffects>) -> Bool
    mutating func summarizeFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!) -> Bool

    /// Summarize the callee side effects of a call instruction using this
    /// FunctionSideEffects object without analyzing the callee function bodies or
    /// scheduling the callees for bottom-up propagation.
    ///
    /// The side effects are represented from the callee's perspective. Parameter
    /// effects are not translated into information on the caller's argument, and
    /// local effects are not dropped.
    ///
    /// Return true if this call-site's effects are summarized without visiting
    /// the callee.
    mutating func summarizeCall(_ fullApply: swift.FullApplySite) -> Bool

    /// Merge effects directly from \p RHS.
    mutating func mergeFrom(_ RHS: UnsafePointer<swift.FunctionSideEffects>) -> Bool

    /// Merge the effects represented in CalleeEffects into this
    /// FunctionSideEffects object. CalleeEffects must correspond to at least one
    /// callee at the apply site `FAS`. Merging drops any local effects, and
    /// translates parameter effects into effects on the caller-side arguments.
    ///
    /// The full caller-side effects at a call site can be obtained with
    /// SideEffectsAnalysis::getCallSiteEffects().
    mutating func mergeFromApply(_ CalleeEffects: UnsafePointer<swift.FunctionSideEffects>, _ FAS: swift.FullApplySite) -> Bool

    /// Analyze the side-effects of a single SIL instruction \p I.
    /// Visited callees are added to \p BottomUpOrder until \p RecursionDepth
    /// reaches MaxRecursionDepth.
    mutating func analyzeInstruction(_ I: UnsafeMutablePointer<swift.SILInstruction>!)

    /// Print the function effects.
    mutating func dump()

    /// Does the function allocate objects, boxes, etc., i.e. everything which
    /// has a reference count.
    mutating func mayAllocObjects() -> Bool

    /// Can this function trap or exit the program in any way?
    mutating func mayTrap() -> Bool

    /// Does this function read a reference count other than with retain or
    /// release instructions, e.g. isUnique?
    mutating func mayReadRC() -> Bool

    /// Gets the memory behavior considering the global effects and
    /// all parameter effects. If \p ScanKind equals ignoreRetains then retain
    /// instructions are considered as side effects.
    mutating func getMemBehavior(_ ScanKind: swift.RetainObserveKind) -> swift.SILInstruction.MemoryBehavior

    /// Gets the memory behavior for an argument.
    ///
    /// This is derived from the combined argument and the global effects.
    /// Also the argument type and convention are considered.
    mutating func getArgumentBehavior(_ applySite: swift.FullApplySite, _ argIdx: UInt32) -> swift.SILInstruction.MemoryBehavior

    /// Get the global effects for the function. These are effects which cannot
    /// be associated to a specific parameter, e.g. writes to global variables
    /// or writes to unknown pointers.
    mutating func getGlobalEffects() -> UnsafePointer<swift.FunctionSideEffectFlags>

    /// Get the array of parameter effects. If a side-effect can be associated
    /// to a specific parameter, it is contained here instead of the global
    /// effects.
    /// Note that if a parameter effect is mayRelease(), it means that the
    /// global function effects can be anything, because the destructor of an
    /// object can have arbitrary side effects.
    mutating func getParameterEffects() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23FunctionSideEffectFlagsEEE
  }

  /// The kind of array operation identified by looking at the semantics attribute
  /// of the called function.
  enum ArrayCallKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case none
    @available(swift, obsoleted: 3, renamed: "none")
    static var None: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "none", message: "Not available in Swift")
    static var kNone: swift.ArrayCallKind { get }
    case arrayPropsIsNativeTypeChecked
    @available(swift, obsoleted: 3, renamed: "arrayPropsIsNativeTypeChecked")
    static var ArrayPropsIsNativeTypeChecked: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayPropsIsNativeTypeChecked", message: "Not available in Swift")
    static var kArrayPropsIsNativeTypeChecked: swift.ArrayCallKind { get }
    case checkSubscript
    @available(swift, obsoleted: 3, renamed: "checkSubscript")
    static var CheckSubscript: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "checkSubscript", message: "Not available in Swift")
    static var kCheckSubscript: swift.ArrayCallKind { get }
    case checkIndex
    @available(swift, obsoleted: 3, renamed: "checkIndex")
    static var CheckIndex: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "checkIndex", message: "Not available in Swift")
    static var kCheckIndex: swift.ArrayCallKind { get }
    case getCount
    @available(swift, obsoleted: 3, renamed: "getCount")
    static var GetCount: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "getCount", message: "Not available in Swift")
    static var kGetCount: swift.ArrayCallKind { get }
    case getCapacity
    @available(swift, obsoleted: 3, renamed: "getCapacity")
    static var GetCapacity: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "getCapacity", message: "Not available in Swift")
    static var kGetCapacity: swift.ArrayCallKind { get }
    case getElement
    @available(swift, obsoleted: 3, renamed: "getElement")
    static var GetElement: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "getElement", message: "Not available in Swift")
    static var kGetElement: swift.ArrayCallKind { get }
    case getElementAddress
    @available(swift, obsoleted: 3, renamed: "getElementAddress")
    static var GetElementAddress: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "getElementAddress", message: "Not available in Swift")
    static var kGetElementAddress: swift.ArrayCallKind { get }
    case makeMutable
    @available(swift, obsoleted: 3, renamed: "makeMutable")
    static var MakeMutable: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "makeMutable", message: "Not available in Swift")
    static var kMakeMutable: swift.ArrayCallKind { get }
    case endMutation
    @available(swift, obsoleted: 3, renamed: "endMutation")
    static var EndMutation: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "endMutation", message: "Not available in Swift")
    static var kEndMutation: swift.ArrayCallKind { get }
    case mutateUnknown
    @available(swift, obsoleted: 3, renamed: "mutateUnknown")
    static var MutateUnknown: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "mutateUnknown", message: "Not available in Swift")
    static var kMutateUnknown: swift.ArrayCallKind { get }
    case reserveCapacityForAppend
    @available(swift, obsoleted: 3, renamed: "reserveCapacityForAppend")
    static var ReserveCapacityForAppend: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "reserveCapacityForAppend", message: "Not available in Swift")
    static var kReserveCapacityForAppend: swift.ArrayCallKind { get }
    case withUnsafeMutableBufferPointer
    @available(swift, obsoleted: 3, renamed: "withUnsafeMutableBufferPointer")
    static var WithUnsafeMutableBufferPointer: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "withUnsafeMutableBufferPointer", message: "Not available in Swift")
    static var kWithUnsafeMutableBufferPointer: swift.ArrayCallKind { get }
    case appendContentsOf
    @available(swift, obsoleted: 3, renamed: "appendContentsOf")
    static var AppendContentsOf: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "appendContentsOf", message: "Not available in Swift")
    static var kAppendContentsOf: swift.ArrayCallKind { get }
    case appendElement
    @available(swift, obsoleted: 3, renamed: "appendElement")
    static var AppendElement: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "appendElement", message: "Not available in Swift")
    static var kAppendElement: swift.ArrayCallKind { get }
    case arrayInit
    @available(swift, obsoleted: 3, renamed: "arrayInit")
    static var ArrayInit: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayInit", message: "Not available in Swift")
    static var kArrayInit: swift.ArrayCallKind { get }
    case arrayInitEmpty
    @available(swift, obsoleted: 3, renamed: "arrayInitEmpty")
    static var ArrayInitEmpty: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayInitEmpty", message: "Not available in Swift")
    static var kArrayInitEmpty: swift.ArrayCallKind { get }
    case arrayUninitialized
    @available(swift, obsoleted: 3, renamed: "arrayUninitialized")
    static var ArrayUninitialized: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayUninitialized", message: "Not available in Swift")
    static var kArrayUninitialized: swift.ArrayCallKind { get }
    case arrayUninitializedIntrinsic
    @available(swift, obsoleted: 3, renamed: "arrayUninitializedIntrinsic")
    static var ArrayUninitializedIntrinsic: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayUninitializedIntrinsic", message: "Not available in Swift")
    static var kArrayUninitializedIntrinsic: swift.ArrayCallKind { get }
    case arrayFinalizeIntrinsic
    @available(swift, obsoleted: 3, renamed: "arrayFinalizeIntrinsic")
    static var ArrayFinalizeIntrinsic: swift.ArrayCallKind { get }
    @available(*, unavailable, renamed: "arrayFinalizeIntrinsic", message: "Not available in Swift")
    static var kArrayFinalizeIntrinsic: swift.ArrayCallKind { get }
  }

  /// Return true is the given function is an array semantics call.
  static func getArraySemanticsKind(_ f: UnsafeMutablePointer<swift.SILFunction>!) -> swift.ArrayCallKind

  /// Wrapper around array semantic calls.
  struct ArraySemanticsCall {

    /// Match calls with any array semantic.
    init<NodeTy>(_ node: NodeTy)

    /// Match calls with a specific array semantic.
    init<NodeTy>(_ node: NodeTy, _ semanticName: llvm.StringRef)

    /// Match array semantic calls.
    init(_ apply: UnsafeMutablePointer<swift.ApplyInst>!, _ SemanticStr: llvm.StringRef, _ MatchPartialName: Bool)

    /// Match array semantic calls.
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ semanticName: llvm.StringRef, _ matchPartialName: Bool)

    /// Match array semantic calls.
    init(_ V: swift.SILValue, _ semanticName: llvm.StringRef, _ matchPartialName: Bool)
    init()

    /// Can we hoist this call.
    mutating func canHoist(_ To: UnsafeMutablePointer<swift.SILInstruction>!, _ DT: UnsafeMutablePointer<swift.DominanceInfo>!) -> Bool

    /// Determine which kind of array semantics call this is.
    mutating func getKind() -> swift.ArrayCallKind

    /// Does this semantic call has a self argument.
    ///
    /// For example, kArrayInit and kArrayUninitialized don't.
    mutating func hasSelf() -> Bool

    /// Does this instruction have guaranteed self.
    ///
    /// Once +0 self is enabled, this can be removed in favor of just hasSelf()
    /// since all of these methods will have guaranteed self always.
    mutating func hasGuaranteedSelf() -> Bool

    /// Get the self argument.
    mutating func getSelf() -> swift.SILValue

    /// Get the self argument operand.
    mutating func getSelfOperand() -> UnsafeMutablePointer<swift.Operand>

    /// Returns true if this array.get_element call returns the element
    /// as a direct result (and not as an indirect result).
    mutating func hasGetElementDirectResult() -> Bool

    /// Returns the wasNativeTypeChecked argument of this
    /// array.get_element call.
    mutating func getTypeCheckedArgument() -> swift.SILValue

    /// Returns the matchingSubscriptCheck argument of this
    /// array.get_element call.
    mutating func getSubscriptCheckArgument() -> swift.SILValue

    /// Get the index for operations that have one.
    mutating func getIndex() -> swift.SILValue

    /// Get the index as a constant if possible.
    mutating func getConstantIndex() -> llvm.__CxxTemplateInstN4llvm8OptionalIxEE

    /// Get the array.props.isNativeTypeChecked argument.
    mutating func getArrayPropertyIsNativeTypeChecked() -> swift.SILValue

    /// Get the count used for this array initialization.
    ///
    /// Returns SILValue() if this is not an array initialization call or the call
    /// can't be parsed.
    mutating func getInitializationCount() -> swift.SILValue

    /// Get the array value returned by an array initialization call.
    ///
    /// Returns SILValue() if this is not an array initialization call.
    mutating func getArrayValue() -> swift.SILValue

    /// Get the array element storage pointer returned by an array initialization
    /// call.
    ///
    /// Returns SILValue() if this is not an array initialization call or the call
    /// can't be parsed.
    mutating func getArrayElementStoragePointer() -> swift.SILValue

    /// Remove the semantics call replacing it by a release of any @owned
    /// parameter.
    mutating func removeCall()

    /// Replace a call to get_element by a value.
    ///
    /// Preconditions:
    /// The value \p V must dominate this get_element call.
    /// This must be a get_element call.
    ///
    /// Returns true on success, false otherwise.
    mutating func replaceByValue(_ V: swift.SILValue) -> Bool

    /// Replace a call to append(contentsOf: ) with a series of
    /// append(element: ) calls.
    mutating func replaceByAppendingValues(_ AppendFn: UnsafeMutablePointer<swift.SILFunction>!, _ ReserveFn: UnsafeMutablePointer<swift.SILFunction>!, _ Vals: UnsafePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>, _ Subs: swift.SubstitutionMap) -> Bool

    /// Hoist the call to the insert point.
    mutating func hoist(_ InsertBefore: UnsafeMutablePointer<swift.SILInstruction>!, _ DT: UnsafeMutablePointer<swift.DominanceInfo>!)

    /// Copy the call to the insert point and return the newly created call.
    mutating func copyTo(_ InsertBefore: UnsafeMutablePointer<swift.SILInstruction>!, _ DT: UnsafeMutablePointer<swift.DominanceInfo>!) -> UnsafeMutablePointer<swift.ApplyInst>!
    mutating func getCallResult() -> swift.SILValue

    /// Is this a call which is not used to mutate the array.
    mutating func doesNotChangeArray() -> Bool

    /// Could this array be backed by an NSArray.
    mutating func mayHaveBridgedObjectElementType() -> Bool

    /// Can this function be inlined by the early inliner.
    mutating func canInlineEarly() -> Bool
  }

  /// An abstract base class for interprocedural analysis which are computed in
  /// bottom-up order of the call-graph.
  /// It provides utilities for automatic invalidation and updating the analysis.
  struct BottomUpIPAnalysis {
  }

  /// A full function application.
  struct FullApplySite {
    init()
    init(_ inst: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ inst: UnsafeMutablePointer<swift.ApplyInst>!)
    init(_ inst: UnsafeMutablePointer<swift.BeginApplyInst>!)
    init(_ inst: UnsafeMutablePointer<swift.TryApplyInst>!)
    static func isa(_ node: UnsafeMutablePointer<swift.SILNode>!) -> swift.FullApplySite
    mutating func getKind() -> swift.FullApplySiteKind
    mutating func hasIndirectSILResults() -> Bool

    /// If our apply site has a single direct result SILValue, return that
    /// SILValue. Return SILValue() otherwise.
    ///
    /// This means that:
    ///
    /// 1. If we have an ApplyInst, we just visit the apply.
    /// 2. If we have a TryApplyInst, we visit the first argument of the normal
    ///    block.
    /// 3. If we have a BeginApplyInst, we return SILValue() since the begin_apply
    ///    yields values instead of returning them. A returned value should only
    ///    be valid after a full apply site has completely finished executing.
    mutating func getSingleDirectResult() -> swift.SILValue
    mutating func getNumIndirectSILResults() -> UInt32
    mutating func getIndirectSILResults() -> swift.OperandValueArrayRef
    mutating func getArgumentsWithoutIndirectResults() -> swift.OperandValueArrayRef
    mutating func getInoutArguments() -> swift.InoutArgumentRange

    /// Returns true if \p op is the callee operand of this apply site
    /// and not an argument operand.
    mutating func isCalleeOperand(_ op: UnsafePointer<swift.Operand>) -> Bool

    /// Is this an ApplySite that begins the evaluation of a coroutine.
    mutating func beginsCoroutineEvaluation() -> Bool

    /// If this is a terminator apply site, then pass a builder to insert at the
    /// first instruction of each successor to \p func. Otherwise, pass a builder
    /// to insert at std::next(Inst).
    ///
    /// The intention is that this abstraction will enable the compiler writer to
    /// ignore whether or not an apply site is a terminator when inserting
    /// instructions after an apply site. This results in eliminating unnecessary
    /// if-else code otherwise required to handle such situations.
    ///
    /// NOTE: We pass std::next() for begin_apply. If one wishes to insert code
    /// /after/ the end_apply/abort_apply, please use instead
    /// insertAfterFullEvaluation.
    mutating func insertAfterInvocation(_ func: llvm.__CxxTemplateInstN4llvm12function_refIFvRN5swift10SILBuilderEEEE)

    /// Pass a builder with insertion points that are guaranteed to be immediately
    /// after this full apply site has completely finished executing.
    ///
    /// This is just like insertAfterInvocation except that if the full apply site
    /// is a begin_apply, we pass the insertion points after the end_apply,
    /// abort_apply rather than an insertion point right after the
    /// begin_apply. For such functionality, please invoke insertAfterInvocation.
    mutating func insertAfterFullEvaluation(_ func: llvm.__CxxTemplateInstN4llvm12function_refIFvRN5swift10SILBuilderEEEE)

    /// Returns true if \p op is an operand that passes an indirect
    /// result argument to the apply site.
    mutating func isIndirectResultOperand(_ op: UnsafePointer<swift.Operand>) -> Bool
    static func getFromOpaqueValue(_ p: UnsafeMutableRawPointer!) -> swift.FullApplySite
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
  }
  struct ApplySiteKind {
    struct innerty : Equatable, RawRepresentable {
      init(_ rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type)
      init(rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type)
      var rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type
      typealias RawValue = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type
    }
    var value: swift.ApplySiteKind.innerty
    init(_ kind: swift.SILInstructionKind)
    init(_ value: swift.ApplySiteKind.innerty)
    static func fromNodeKind(_ kind: swift.SILInstructionKind) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13ApplySiteKindEEE
  }

  /// An apply instruction.
  struct ApplySite {
    init()
    init(_ inst: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ inst: UnsafeMutablePointer<swift.ApplyInst>!)
    init(_ inst: UnsafeMutablePointer<swift.PartialApplyInst>!)
    init(_ inst: UnsafeMutablePointer<swift.TryApplyInst>!)
    init(_ inst: UnsafeMutablePointer<swift.BeginApplyInst>!)
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    static func isa(_ node: UnsafeMutablePointer<swift.SILNode>!) -> swift.ApplySite
    mutating func getKind() -> swift.ApplySiteKind
    mutating func getInstruction() -> UnsafeMutablePointer<swift.SILInstruction>!
    mutating func getLoc() -> swift.SILLocation
    mutating func getDebugScope() -> UnsafePointer<swift.SILDebugScope>!
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getParent() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Return the callee operand as a value.
    mutating func getCallee() -> swift.SILValue

    /// Return the callee operand.
    mutating func getCalleeOperand() -> UnsafeMutablePointer<swift.Operand>!

    /// Return the callee operand.
    mutating func getCalleeOperand() -> UnsafePointer<swift.Operand>!

    /// Return the callee value by looking through function conversions until we
    /// find a function_ref, partial_apply, or unrecognized callee value.
    mutating func getCalleeOrigin() -> swift.SILValue

    /// Gets the referenced function by looking through partial apply,
    /// convert_function, and thin to thick function until we find a function_ref.
    mutating func getCalleeFunction() -> UnsafeMutablePointer<swift.SILFunction>!

    /// Return the referenced function if the callee is a function_ref
    /// instruction.
    mutating func getReferencedFunctionOrNull() -> UnsafeMutablePointer<swift.SILFunction>!

    /// Return the referenced function if the callee is a function_ref like
    /// instruction.
    ///
    /// WARNING: This not necessarily the function that will be called at runtime.
    /// If the callee is a (prev_)dynamic_function_ref the actual function called
    /// might be different because it could be dynamically replaced at runtime.
    ///
    /// If the client of this API wants to look at the content of the returned SIL
    /// function it should call getReferencedFunctionOrNull() instead.
    mutating func getInitiallyReferencedFunction() -> UnsafeMutablePointer<swift.SILFunction>!

    /// Should we optimize this call.
    /// Calls to (previous_)dynamic_function_ref have a dynamic target function so
    /// we should not optimize them.
    mutating func canOptimize() -> Bool

    /// Return the type.
    mutating func getType() -> swift.SILType

    /// Get the conventions of the callee without the applied substitutions.
    mutating func getOrigCalleeConv() -> swift.SILFunctionConventions
    mutating func getSubstCalleeSILType() -> swift.SILType

    /// Get the conventions of the callee with the applied substitutions.
    mutating func getSubstCalleeConv() -> swift.SILFunctionConventions
    mutating func isAsync() -> Bool

    /// Returns true if the callee function is annotated with
    /// @_semantics("programtermination_point")
    mutating func isCalleeKnownProgramTerminationPoint() -> Bool

    /// Check if this is a call of a never-returning function.
    mutating func isCalleeNoReturn() -> Bool
    mutating func isCalleeThin() -> Bool

    /// True if this application has generic substitutions.
    mutating func hasSubstitutions() -> Bool

    /// The substitutions used to bind the generic arguments of this function.
    mutating func getSubstitutionMap() -> swift.SubstitutionMap

    /// Return the associated specialization information.
    mutating func getSpecializationInfo() -> UnsafePointer<swift.GenericSpecializationInformation>!

    /// Return an operand list corresponding to the applied arguments.
    mutating func getArgumentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Return a list of applied argument values.
    mutating func getArguments() -> swift.OperandValueArrayRef

    /// Return the number of applied arguments.
    mutating func getNumArguments() -> UInt32

    /// Return the apply operand for the given applied argument index.
    mutating func getArgumentRef(_ i: UInt32) -> UnsafeMutablePointer<swift.Operand>

    /// Return the ith applied argument.
    mutating func getArgument(_ i: UInt32) -> swift.SILValue

    /// Set the ith applied argument.
    mutating func setArgument(_ i: UInt32, _ V: swift.SILValue)

    /// Return the operand index of the first applied argument.
    mutating func getOperandIndexOfFirstArgument() -> UInt32

    /// Returns true if \p oper is an argument operand and not the callee
    /// operand.
    mutating func isArgumentOperand(_ oper: UnsafePointer<swift.Operand>) -> Bool

    /// Return the applied argument index for the given operand.
    mutating func getAppliedArgIndex(_ oper: UnsafePointer<swift.Operand>) -> UInt32

    /// Return the callee's function argument index corresponding to the first
    /// applied argument: 0 for full applies; >= 0 for partial applies.
    mutating func getCalleeArgIndexOfFirstAppliedArg() -> UInt32

    /// Return the callee's function argument index corresponding to the given
    /// apply operand. Each function argument index identifies a
    /// SILFunctionArgument in the callee and can be used as a
    /// SILFunctionConvention argument index.
    ///
    /// Note: Passing an applied argument index into SILFunctionConvention, as
    /// opposed to a function argument index, is incorrect.
    mutating func getCalleeArgIndex(_ oper: UnsafePointer<swift.Operand>) -> UInt32

    /// Return the SILArgumentConvention for the given applied argument operand.
    mutating func getArgumentConvention(_ oper: UnsafePointer<swift.Operand>) -> swift.SILArgumentConvention

    /// Return true if 'self' is an applied argument.
    mutating func hasSelfArgument() -> Bool

    /// Return the applied 'self' argument value.
    mutating func getSelfArgument() -> swift.SILValue

    /// Return the 'self' apply operand.
    mutating func getSelfArgumentOperand() -> UnsafeMutablePointer<swift.Operand>

    /// Return a list of applied arguments without self.
    mutating func getArgumentsWithoutSelf() -> swift.OperandValueArrayRef

    /// Returns true if \p op is an operand that passes an indirect
    /// result argument to the apply site.
    mutating func isIndirectResultOperand(_ op: UnsafePointer<swift.Operand>) -> Bool

    /// Return whether the given apply is of a formally-throwing function
    /// which is statically known not to throw.
    mutating func isNonThrowing() -> Bool
    static func getFromOpaqueValue(_ p: UnsafeMutableRawPointer!) -> swift.ApplySite
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
    mutating func dump()

    /// Attempt to cast this apply site to a full apply site, returning None on
    /// failure.
    mutating func asFullApplySite() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13FullApplySiteEEE
  }
  struct FullApplySiteKind {
    struct innerty : Equatable, RawRepresentable {
      init(_ rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type)
      init(rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type)
      var rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type
      typealias RawValue = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift18SILInstructionKindELb1EEE.type
    }
    var value: swift.FullApplySiteKind.innerty
    init(_ kind: swift.SILInstructionKind)
    init(_ value: swift.FullApplySiteKind.innerty)
    static func fromNodeKind(_ kind: swift.SILInstructionKind) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift17FullApplySiteKindEEE
  }

  /// / This class maps values to unique indices.
  struct __CxxTemplateInstN5swift15ValueEnumeratorIPNS_9ValueBaseEmEE {
    init()

    /// Return the index of value \p v.
    mutating func getIndex(_ v: UnsafePointer<UnsafeMutablePointer<swift.ValueBase>?>) -> UInt

    /// Forget about key \p v.
    mutating func invalidateValue(_ v: UnsafePointer<UnsafeMutablePointer<swift.ValueBase>?>)

    /// Clear the enumeration state of the
    mutating func clear()
  }

  /// / This class maps values to unique indices.
  struct __CxxTemplateInstN5swift15ValueEnumeratorIPNS_7SILNodeEmEE {
    init()

    /// Return the index of value \p v.
    mutating func getIndex(_ v: UnsafePointer<UnsafeMutablePointer<swift.SILNode>?>) -> UInt

    /// Forget about key \p v.
    mutating func invalidateValue(_ v: UnsafePointer<UnsafeMutablePointer<swift.SILNode>?>)

    /// Clear the enumeration state of the
    mutating func clear()
  }
  typealias Atomicity = swift.RefCountingInst.Atomicity

  /// This class stores a lexical scope as it is represented in the
  /// debug info. In contrast to LLVM IR, SILDebugScope also holds all
  /// the inlining information. In LLVM IR the inline info is part of
  /// DILocation.
  struct SILDebugScope {

    /// The AST node this lexical scope represents.
    var Loc: swift.SILLocation

    /// Always points to the parent lexical scope.
    /// For top-level scopes, this is the SILFunction.
    var Parent: llvm.__CxxTemplateInstN4llvm12PointerUnionIJPKN5swift13SILDebugScopeEPNS1_11SILFunctionEEEE

    /// An optional chain of inlined call sites.
    ///
    /// If this scope is inlined, this points to a special "scope" that
    /// holds the location of the call site.
    var InlinedCallSite: UnsafePointer<swift.SILDebugScope>!
    init(_ Loc: swift.SILLocation, _ SILFn: UnsafeMutablePointer<swift.SILFunction>!, _ ParentScope: UnsafePointer<swift.SILDebugScope>!, _ InlinedCallSite: UnsafePointer<swift.SILDebugScope>!)

    /// Create a scope for an artificial function.
    init(_ Loc: swift.SILLocation)
    mutating func getLoc() -> swift.SILLocation

    /// Return the function this scope originated from before being inlined.
    mutating func getInlinedFunction() -> UnsafeMutablePointer<swift.SILFunction>!

    /// Return the parent function of this scope. If the scope was
    /// inlined this recursively returns the function it was inlined
    /// into.
    mutating func getParentFunction() -> UnsafeMutablePointer<swift.SILFunction>!

    /// If this is a debug scope associated with an inlined call site, return the
    /// SILLocation associated with the call site resulting from the final
    /// inlining.
    ///
    /// This allows one to emit diagnostics based off of inlined code's final
    /// location in the function that was inlined into.
    mutating func getOutermostInlineLocation() -> swift.SILLocation
    mutating func print(_ SM: UnsafeMutablePointer<swift.SourceManager>, _ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Indent: UInt32)
    @warn_unqualified_access
    mutating func print(_ Mod: UnsafeMutablePointer<swift.SILModule>)
  }

  /// A global variable that has been referenced in SIL.
  struct SILGlobalVariable {
    typealias const_iterator = swift.SILBasicBlock.const_iterator
    static func create(_ Module: UnsafeMutablePointer<swift.SILModule>, _ Linkage: swift.SILLinkage, _ IsSerialized: swift.IsSerialized_t, _ MangledName: llvm.StringRef, _ LoweredType: swift.SILType, _ Loc: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11SILLocationEEE, _ Decl: UnsafeMutablePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.SILGlobalVariable>!
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getLoweredType() -> swift.SILType
    mutating func getLoweredTypeInContext(_ context: swift.TypeExpansionContext) -> swift.SILType
    mutating func getName() -> llvm.StringRef
    mutating func setDeclaration(_ isD: Bool)

    /// True if this is a definition of the variable.
    mutating func isDefinition() -> Bool

    /// Get this function's linkage attribute.
    mutating func getLinkage() -> swift.SILLinkage
    mutating func setLinkage(_ linkage: swift.SILLinkage)

    /// Get this global variable's serialized attribute.
    mutating func isSerialized() -> swift.IsSerialized_t
    mutating func setSerialized(_ isSerialized: swift.IsSerialized_t)

    /// Is this an immutable 'let' property?
    mutating func isLet() -> Bool
    mutating func setLet(_ isLet: Bool)
    mutating func getDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Check if the function has a location.
    /// FIXME: All functions should have locations, so this method should not be
    /// necessary.
    mutating func hasLocation() -> Bool

    /// Get the source location of the function.
    mutating func getLocation() -> swift.SILLocation

    /// Returns the value of the static initializer or null if the global has no
    /// static initializer.
    mutating func getStaticInitializerValue() -> UnsafeMutablePointer<swift.SILInstruction>!

    /// Returns true if the global is a statically initialized heap object.
    mutating func isInitializedObject() -> Bool
    mutating func begin() -> swift.SILGlobalVariable.const_iterator
    mutating func end() -> swift.SILGlobalVariable.const_iterator

    /// Returns true if \p I is a valid instruction to be contained in the
    /// static initializer.
    static func isValidStaticInitializerInst(_ I: UnsafePointer<swift.SILInstruction>!, _ M: UnsafeMutablePointer<swift.SILModule>) -> Bool

    /// Returns the usub_with_overflow builtin if \p TE extracts the result of
    /// such a subtraction, which is required to have an integer_literal as right
    /// operand.
    static func getOffsetSubtract(_ TE: UnsafePointer<swift.TupleExtractInst>!, _ M: UnsafeMutablePointer<swift.SILModule>) -> UnsafeMutablePointer<swift.BuiltinInst>!
    mutating func dropAllReferences()

    /// Return whether this variable corresponds to a Clang node.
    mutating func hasClangNode() -> Bool

    /// Return the Clang node associated with this variable if it has one.
    mutating func getClangNode() -> swift.ClangNode
    mutating func getClangDecl() -> UnsafePointer<clang.Decl>!

    /// verify - Run the IR verifier to make sure that the variable follows
    /// invariants.
    mutating func verify()

    /// Pretty-print the variable.
    mutating func dump(_ Verbose: Bool)

    /// Pretty-print the variable.
    ///
    /// This is a separate entry point for ease of debugging.
    mutating func dump()

    /// Pretty-print the variable to the designated stream as a 'sil_global'
    /// definition.
    ///
    /// \param Verbose In verbose mode, print the SIL locations.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool)

    /// Pretty-print the variable name using SIL syntax,
    /// '@var_mangled_name'.
    mutating func printName(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
    mutating func getASTContext() -> UnsafeMutablePointer<swift.ASTContext>
  }

  /// Manage the state needed for a SIL pass across multiple, independent
  /// SILBuilder invocations.
  ///
  /// A SIL pass can instantiate a SILBuilderContext object to track information
  /// across multiple, potentially independent invocations of SILBuilder. This
  /// allows utilities used within the pass to construct a new SILBuilder instance
  /// whenever it is convenient or appropriate. For example, a separate SILBuilder
  /// should be constructed whenever the current debug location or insertion point
  /// changed. Reusing the same SILBuilder and calling setInsertionPoint() easily
  /// leads to incorrect debug information.
  struct SILBuilderContext {
    init(_ M: UnsafeMutablePointer<swift.SILModule>, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func setSILConventions(_ silConv: swift.SILModuleConventions)
    mutating func setOpenedArchetypesTracker(_ Tracker: UnsafeMutablePointer<swift.SILOpenedArchetypesTracker>!)
    mutating func getOpenedArchetypesTracker() -> UnsafeMutablePointer<swift.SILOpenedArchetypesTracker>!
  }
  struct SILBuilder {
    init(_ F: UnsafeMutablePointer<swift.SILFunction>)
    init(_ F: UnsafeMutablePointer<swift.SILFunction>, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ I: swift.SILBasicBlock.iterator, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ GlobVar: UnsafeMutablePointer<swift.SILGlobalVariable>!, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ InsertPt: swift.SILBasicBlock.iterator, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)

    /// Build instructions before the given insertion point, inheriting the debug
    /// location.
    ///
    /// SILBuilderContext must outlive this SILBuilder instance.
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ DS: UnsafePointer<swift.SILDebugScope>!, _ C: UnsafeMutablePointer<swift.SILBuilderContext>)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ DS: UnsafePointer<swift.SILDebugScope>!, _ B: UnsafeMutablePointer<swift.SILBuilder>)

    /// Build instructions before the given insertion point, inheriting the debug
    /// location.
    ///
    /// SILBuilderContext must outlive this SILBuilder instance.
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ DS: UnsafePointer<swift.SILDebugScope>!, _ C: UnsafeMutablePointer<swift.SILBuilderContext>)
    mutating func setSILConventions(_ silConv: swift.SILModuleConventions)
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>
    mutating func isInsertingIntoGlobal() -> Bool
    mutating func getTypeExpansionContext() -> swift.TypeExpansionContext
    mutating func getBuilderContext() -> UnsafeMutablePointer<swift.SILBuilderContext>
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getASTContext() -> UnsafeMutablePointer<swift.ASTContext>
    mutating func getTypeLowering(_ T: swift.SILType) -> UnsafePointer<swift.Lowering.TypeLowering>
    mutating func setOpenedArchetypesTracker(_ Tracker: UnsafeMutablePointer<swift.SILOpenedArchetypesTracker>!)
    mutating func getOpenedArchetypesTracker() -> UnsafeMutablePointer<swift.SILOpenedArchetypesTracker>!
    mutating func getOpenedArchetypes() -> UnsafeMutablePointer<swift.SILOpenedArchetypesState>
    mutating func setCurrentDebugScope(_ DS: UnsafePointer<swift.SILDebugScope>!)
    mutating func getCurrentDebugScope() -> UnsafePointer<swift.SILDebugScope>!

    /// Apply a debug location override. If loc is None, the current override is
    /// removed. Otherwise, newly created debug locations use the given location.
    /// Note: the override location does not apply to debug_value[_addr].
    mutating func applyDebugLocOverride(_ loc: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11SILLocationEEE)

    /// Get the current debug location override.
    mutating func getCurrentDebugLocOverride() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11SILLocationEEE

    /// Convenience function for building a SILDebugLocation.
    mutating func getSILDebugLocation(_ Loc: swift.SILLocation) -> swift.SILDebugLocation

    /// If we have a SILFunction, return SILFunction::hasOwnership(). If we have a
    /// SILGlobalVariable, just return false.
    mutating func hasOwnership() -> Bool
    mutating func hasValidInsertionPoint() -> Bool
    mutating func getInsertionBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getInsertionPoint() -> swift.SILBasicBlock.iterator
    mutating func getInsertionPointLoc() -> swift.SILLocation

    /// insertingAtEndOfBlock - Return true if the insertion point is at the end
    /// of the current basic block.  False if we're inserting before an existing
    /// instruction.
    mutating func insertingAtEndOfBlock() -> Bool

    /// clearInsertionPoint - Clear the insertion point: created instructions will
    /// not be inserted into a block.
    mutating func clearInsertionPoint()

    /// setInsertionPoint - Set the insertion point.
    mutating func setInsertionPoint(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ InsertPt: swift.SILBasicBlock.iterator)

    /// setInsertionPoint - Set the insertion point to insert before the specified
    /// instruction.
    mutating func setInsertionPoint(_ I: UnsafeMutablePointer<swift.SILInstruction>!)

    /// setInsertionPoint - Set the insertion point to insert before the specified
    /// instruction.
    mutating func setInsertionPoint(_ IIIter: swift.SILBasicBlock.iterator)

    /// setInsertionPoint - Set the insertion point to insert at the end of the
    /// specified block.
    mutating func setInsertionPoint(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// setInsertionPoint - Set the insertion point to insert at the end of the
    /// specified block.
    mutating func setInsertionPoint(_ BBIter: swift.SILFunction.iterator)

    /// Clients of SILBuilder who want to know about any newly created
    /// instructions can install a SmallVector into the builder to collect them.
    mutating func setTrackingList(_ II: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    mutating func getTrackingList() -> UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!
    mutating func addOpenedArchetypeOperands(_ I: UnsafeMutablePointer<swift.SILInstruction>!)
    static func getPartialApplyResultType(_ context: swift.TypeExpansionContext, _ Ty: swift.SILType, _ ArgCount: UInt32, _ M: UnsafeMutablePointer<swift.SILModule>, _ subs: swift.SubstitutionMap, _ calleeConvention: swift.ParameterConvention, _ onStack: swift.PartialApplyInst.OnStackKind) -> swift.SILType

    /// moveBlockTo - Move a block to immediately before the given iterator.
    mutating func moveBlockTo(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ IP: swift.SILFunction.iterator)

    /// moveBlockTo - Move \p BB to immediately before \p Before.
    mutating func moveBlockTo(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Before: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// moveBlockToEnd - Reorder a block to the end of its containing function.
    mutating func moveBlockToEnd(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Move the insertion point to the end of the given block.
    ///
    /// Assumes that no insertion point is currently active.
    mutating func emitBlock(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// Branch to the given block if there's an active insertion point,
    /// then move the insertion point to the end of that block.
    mutating func emitBlock(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ BranchLoc: swift.SILLocation)

    /// splitBlockForFallthrough - Prepare for the insertion of a terminator.  If
    /// the builder's insertion point is at the end of the current block (as when
    /// SILGen is creating the initial code for a function), just create and
    /// return a new basic block that will be later used for the continue point.
    ///
    /// If the insertion point is valid (i.e., pointing to an existing
    /// instruction) then split the block at that instruction and return the
    /// continuation block.
    mutating func splitBlockForFallthrough() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Convenience for creating a fall-through basic block on-the-fly without
    /// affecting the insertion point.
    mutating func createFallthroughBlock(_ loc: swift.SILLocation, _ targetBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func createAllocStack(_ Loc: swift.SILLocation, _ elementType: swift.SILType, _ Var: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE, _ hasDynamicLifetime: Bool) -> UnsafeMutablePointer<swift.AllocStackInst>!
    mutating func createAllocRef(_ Loc: swift.SILLocation, _ ObjectType: swift.SILType, _ objc: Bool, _ canAllocOnStack: Bool, _ ElementTypes: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7SILTypeEEE, _ ElementCountOperands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.AllocRefInst>!
    mutating func createAllocRefDynamic(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ type: swift.SILType, _ objc: Bool, _ ElementTypes: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7SILTypeEEE, _ ElementCountOperands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.AllocRefDynamicInst>!
    mutating func createAllocValueBuffer(_ Loc: swift.SILLocation, _ valueType: swift.SILType, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.AllocValueBufferInst>!
    mutating func createAllocExistentialBox(_ Loc: swift.SILLocation, _ ExistentialType: swift.SILType, _ ConcreteType: swift.CanType, _ Conformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE) -> UnsafeMutablePointer<swift.AllocExistentialBoxInst>!
    mutating func createApply(_ Loc: swift.SILLocation, _ Fn: swift.SILValue, _ Subs: swift.SubstitutionMap, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ isNonThrowing: Bool, _ SpecializationInfo: UnsafePointer<swift.GenericSpecializationInformation>!) -> UnsafeMutablePointer<swift.ApplyInst>!
    mutating func createTryApply(_ Loc: swift.SILLocation, _ fn: swift.SILValue, _ subs: swift.SubstitutionMap, _ args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ normalBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ errorBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ SpecializationInfo: UnsafePointer<swift.GenericSpecializationInformation>!) -> UnsafeMutablePointer<swift.TryApplyInst>!
    mutating func createPartialApply(_ Loc: swift.SILLocation, _ Fn: swift.SILValue, _ Subs: swift.SubstitutionMap, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ CalleeConvention: swift.ParameterConvention, _ OnStack: swift.PartialApplyInst.OnStackKind, _ SpecializationInfo: UnsafePointer<swift.GenericSpecializationInformation>!) -> UnsafeMutablePointer<swift.PartialApplyInst>!
    mutating func createBeginApply(_ Loc: swift.SILLocation, _ Fn: swift.SILValue, _ Subs: swift.SubstitutionMap, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ isNonThrowing: Bool, _ SpecializationInfo: UnsafePointer<swift.GenericSpecializationInformation>!) -> UnsafeMutablePointer<swift.BeginApplyInst>!
    mutating func createAbortApply(_ loc: swift.SILLocation, _ beginApply: swift.SILValue) -> UnsafeMutablePointer<swift.AbortApplyInst>!
    mutating func createEndApply(_ loc: swift.SILLocation, _ beginApply: swift.SILValue) -> UnsafeMutablePointer<swift.EndApplyInst>!
    mutating func createBuiltin(_ Loc: swift.SILLocation, _ Name: swift.Identifier, _ ResultTy: swift.SILType, _ Subs: swift.SubstitutionMap, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.BuiltinInst>!

    /// Create a binary function with the signature: OpdTy, OpdTy -> ResultTy.
    mutating func createBuiltinBinaryFunction(_ Loc: swift.SILLocation, _ Name: llvm.StringRef, _ OpdTy: swift.SILType, _ ResultTy: swift.SILType, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.BuiltinInst>!
    mutating func createBuiltinBinaryFunctionWithTwoOpTypes(_ Loc: swift.SILLocation, _ Name: llvm.StringRef, _ OpdTy1: swift.SILType, _ OpdTy2: swift.SILType, _ ResultTy: swift.SILType, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.BuiltinInst>!

    /// Create a binary function with the signature:
    /// OpdTy, OpdTy, Int1 -> (OpdTy, Int1)
    mutating func createBuiltinBinaryFunctionWithOverflow(_ Loc: swift.SILLocation, _ Name: llvm.StringRef, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.BuiltinInst>!
    mutating func createFunctionRefFor(_ Loc: swift.SILLocation, _ f: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafeMutablePointer<swift.FunctionRefBaseInst>!
    mutating func createFunctionRef(_ Loc: swift.SILLocation, _ f: UnsafeMutablePointer<swift.SILFunction>!, _ kind: swift.SILInstructionKind) -> UnsafeMutablePointer<swift.FunctionRefBaseInst>!
    mutating func createFunctionRef(_ Loc: swift.SILLocation, _ f: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafeMutablePointer<swift.FunctionRefInst>!
    mutating func createDynamicFunctionRef(_ Loc: swift.SILLocation, _ f: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafeMutablePointer<swift.DynamicFunctionRefInst>!
    mutating func createPreviousDynamicFunctionRef(_ Loc: swift.SILLocation, _ f: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafeMutablePointer<swift.PreviousDynamicFunctionRefInst>!
    mutating func createAllocGlobal(_ Loc: swift.SILLocation, _ g: UnsafeMutablePointer<swift.SILGlobalVariable>!) -> UnsafeMutablePointer<swift.AllocGlobalInst>!
    mutating func createGlobalAddr(_ Loc: swift.SILLocation, _ g: UnsafeMutablePointer<swift.SILGlobalVariable>!) -> UnsafeMutablePointer<swift.GlobalAddrInst>!
    mutating func createGlobalAddr(_ Loc: swift.SILLocation, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.GlobalAddrInst>!
    mutating func createGlobalValue(_ Loc: swift.SILLocation, _ g: UnsafeMutablePointer<swift.SILGlobalVariable>!) -> UnsafeMutablePointer<swift.GlobalValueInst>!
    mutating func createBaseAddrForOffset(_ Loc: swift.SILLocation, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.BaseAddrForOffsetInst>!
    mutating func createIntegerLiteral(_ E: OpaquePointer!) -> UnsafeMutablePointer<swift.IntegerLiteralInst>!
    mutating func createIntegerLiteral(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Value: intmax_t) -> UnsafeMutablePointer<swift.IntegerLiteralInst>!
    mutating func createIntegerLiteral(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Value: UnsafePointer<llvm.APInt>) -> UnsafeMutablePointer<swift.IntegerLiteralInst>!
    mutating func createFloatLiteral(_ E: OpaquePointer!) -> UnsafeMutablePointer<swift.FloatLiteralInst>!
    mutating func createFloatLiteral(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Value: UnsafePointer<llvm.APFloat>) -> UnsafeMutablePointer<swift.FloatLiteralInst>!
    mutating func createStringLiteral(_ Loc: swift.SILLocation, _ text: llvm.StringRef, _ encoding: swift.StringLiteralInst.Encoding) -> UnsafeMutablePointer<swift.StringLiteralInst>!
    mutating func createStringLiteral(_ Loc: swift.SILLocation, _ text: UnsafePointer<llvm.Twine>, _ encoding: swift.StringLiteralInst.Encoding) -> UnsafeMutablePointer<swift.StringLiteralInst>!

    /// If \p LV is non-trivial, return a \p Qualifier load of \p LV. If \p LV is
    /// trivial, use trivial instead.
    ///
    /// *NOTE* The SupportUnqualifiedSIL is an option to ease the bring up of
    /// Semantic SIL. It enables a pass that must be able to run on both Semantic
    /// SIL and non-Semantic SIL. It has a default argument of false, so if this
    /// is not necessary for your pass, just ignore the parameter.
    mutating func createTrivialLoadOr(_ Loc: swift.SILLocation, _ LV: swift.SILValue, _ Qualifier: swift.LoadOwnershipQualifier, _ SupportUnqualifiedSIL: Bool) -> UnsafeMutablePointer<swift.LoadInst>!
    mutating func createLoad(_ Loc: swift.SILLocation, _ LV: swift.SILValue, _ Qualifier: swift.LoadOwnershipQualifier) -> UnsafeMutablePointer<swift.LoadInst>!
    mutating func createKeyPath(_ Loc: swift.SILLocation, _ Pattern: UnsafeMutablePointer<swift.KeyPathPattern>!, _ Subs: swift.SubstitutionMap, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.KeyPathInst>!

    /// Convenience function for calling emitLoad on the type lowering for
    /// non-address values.
    mutating func emitLoadValueOperation(_ Loc: swift.SILLocation, _ LV: swift.SILValue, _ Qualifier: swift.LoadOwnershipQualifier) -> swift.SILValue

    /// Convenience function for calling emitLoad on the type lowering for
    /// non-address values.
    mutating func emitLoweredLoadValueOperation(_ Loc: swift.SILLocation, _ LV: swift.SILValue, _ Qualifier: swift.LoadOwnershipQualifier, _ ExpansionKind: swift.Lowering.TypeLowering.TypeExpansionKind) -> swift.SILValue

    /// Convenience function for calling emitLoweredStore on the type lowering for
    /// non-address values.
    mutating func emitLoweredStoreValueOperation(_ Loc: swift.SILLocation, _ Value: swift.SILValue, _ Addr: swift.SILValue, _ Qual: swift.StoreOwnershipQualifier, _ ExpansionKind: swift.Lowering.TypeLowering.TypeExpansionKind)
    mutating func createLoadBorrow(_ Loc: swift.SILLocation, _ LV: swift.SILValue) -> UnsafeMutablePointer<swift.LoadBorrowInst>!
    mutating func createBeginBorrow(_ Loc: swift.SILLocation, _ LV: swift.SILValue) -> UnsafeMutablePointer<swift.BeginBorrowInst>!

    /// Convenience function for creating a load_borrow on non-trivial values and
    /// load [trivial] on trivial values. Becomes load unqualified in non-ossa
    /// functions.
    mutating func emitLoadBorrowOperation(_ loc: swift.SILLocation, _ v: swift.SILValue) -> swift.SILValue
    mutating func emitBeginBorrowOperation(_ loc: swift.SILLocation, _ v: swift.SILValue) -> swift.SILValue
    mutating func emitEndBorrowOperation(_ loc: swift.SILLocation, _ v: swift.SILValue)

    /// Utility function that returns a trivial store if the stored type is
    /// trivial and a \p Qualifier store if the stored type is non-trivial.
    ///
    /// *NOTE* The SupportUnqualifiedSIL is an option to ease the bring up of
    /// Semantic SIL. It enables a pass that must be able to run on both Semantic
    /// SIL and non-Semantic SIL. It has a default argument of false, so if this
    /// is not necessary for your pass, just ignore the parameter.
    mutating func createTrivialStoreOr(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ DestAddr: swift.SILValue, _ Qualifier: swift.StoreOwnershipQualifier, _ SupportUnqualifiedSIL: Bool) -> UnsafeMutablePointer<swift.StoreInst>!
    mutating func createStore(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ DestAddr: swift.SILValue, _ Qualifier: swift.StoreOwnershipQualifier) -> UnsafeMutablePointer<swift.StoreInst>!

    /// Convenience function for calling emitStore on the type lowering for
    /// non-address values.
    mutating func emitStoreValueOperation(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ DestAddr: swift.SILValue, _ Qualifier: swift.StoreOwnershipQualifier)
    mutating func createEndBorrow(_ loc: swift.SILLocation, _ borrowedValue: swift.SILValue) -> UnsafeMutablePointer<swift.EndBorrowInst>!
    mutating func createBeginAccess(_ loc: swift.SILLocation, _ address: swift.SILValue, _ accessKind: swift.SILAccessKind, _ enforcement: swift.SILAccessEnforcement, _ noNestedConflict: Bool, _ fromBuiltin: Bool) -> UnsafeMutablePointer<swift.BeginAccessInst>!
    mutating func createEndAccess(_ loc: swift.SILLocation, _ address: swift.SILValue, _ aborted: Bool) -> UnsafeMutablePointer<swift.EndAccessInst>!
    mutating func createBeginUnpairedAccess(_ loc: swift.SILLocation, _ address: swift.SILValue, _ buffer: swift.SILValue, _ accessKind: swift.SILAccessKind, _ enforcement: swift.SILAccessEnforcement, _ noNestedConflict: Bool, _ fromBuiltin: Bool) -> UnsafeMutablePointer<swift.BeginUnpairedAccessInst>!
    mutating func createEndUnpairedAccess(_ loc: swift.SILLocation, _ buffer: swift.SILValue, _ enforcement: swift.SILAccessEnforcement, _ aborted: Bool, _ fromBuiltin: Bool) -> UnsafeMutablePointer<swift.EndUnpairedAccessInst>!
    mutating func createAssign(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ DestAddr: swift.SILValue, _ Qualifier: swift.AssignOwnershipQualifier) -> UnsafeMutablePointer<swift.AssignInst>!
    mutating func createAssignByWrapper(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ Dest: swift.SILValue, _ Initializer: swift.SILValue, _ Setter: swift.SILValue, _ Qualifier: swift.AssignOwnershipQualifier) -> UnsafeMutablePointer<swift.AssignByWrapperInst>!
    mutating func createStoreBorrow(_ Loc: swift.SILLocation, _ Src: swift.SILValue, _ DestAddr: swift.SILValue) -> UnsafeMutablePointer<swift.StoreBorrowInst>!

    /// A helper function for emitting store_borrow in operations where one must
    /// handle both ossa and non-ossa code.
    ///
    /// In words:
    ///
    /// * If the function does not have ownership, this just emits an unqualified
    ///   store.
    ///
    /// * If the function has ownership, but the type is trivial, use store
    ///   [trivial].
    ///
    /// * Otherwise, emit an actual store_borrow.
    mutating func emitStoreBorrowOperation(_ loc: swift.SILLocation, _ src: swift.SILValue, _ destAddr: swift.SILValue)
    mutating func createMarkUninitialized(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ k: swift.MarkUninitializedInst.Kind) -> UnsafeMutablePointer<swift.MarkUninitializedInst>!
    mutating func createMarkUninitializedVar(_ Loc: swift.SILLocation, _ src: swift.SILValue) -> UnsafeMutablePointer<swift.MarkUninitializedInst>!
    mutating func createMarkUninitializedRootSelf(_ Loc: swift.SILLocation, _ src: swift.SILValue) -> UnsafeMutablePointer<swift.MarkUninitializedInst>!
    mutating func createMarkFunctionEscape(_ Loc: swift.SILLocation, _ vars: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.MarkFunctionEscapeInst>!
    mutating func createDebugValue(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ Var: swift.SILDebugVariable) -> UnsafeMutablePointer<swift.DebugValueInst>!
    mutating func createDebugValueAddr(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ Var: swift.SILDebugVariable) -> UnsafeMutablePointer<swift.DebugValueAddrInst>!

    /// Create a debug_value_addr if \p src is an address; a debug_value if not.
    mutating func emitDebugDescription(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ Var: swift.SILDebugVariable) -> UnsafeMutablePointer<swift.SILInstruction>!
    mutating func createLoadWeak(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ isTake: swift.IsTake_t) -> UnsafeMutablePointer<swift.LoadWeakInst>!
    mutating func createStoreWeak(_ Loc: swift.SILLocation, _ value: swift.SILValue, _ dest: swift.SILValue, _ isInit: swift.IsInitialization_t) -> UnsafeMutablePointer<swift.StoreWeakInst>!
    mutating func createLoadUnowned(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ isTake: swift.IsTake_t) -> UnsafeMutablePointer<swift.LoadUnownedInst>!
    mutating func createStoreUnowned(_ Loc: swift.SILLocation, _ value: swift.SILValue, _ dest: swift.SILValue, _ isInit: swift.IsInitialization_t) -> UnsafeMutablePointer<swift.StoreUnownedInst>!
    mutating func createUnownedToRef(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.UnownedToRefInst>!
    mutating func createRefToUnowned(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.RefToUnownedInst>!
    mutating func createStrongCopyUnownedValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.StrongCopyUnownedValueInst>!
    mutating func createStrongRetainUnowned(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.StrongRetainUnownedInst>!
    mutating func createUnownedRetain(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.UnownedRetainInst>!
    mutating func createUnownedRelease(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.UnownedReleaseInst>!
    mutating func createUnmanagedToRef(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.UnmanagedToRefInst>!
    mutating func createRefToUnmanaged(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.RefToUnmanagedInst>!
    mutating func createStrongCopyUnmanagedValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.StrongCopyUnmanagedValueInst>!
    mutating func createCopyAddr(_ Loc: swift.SILLocation, _ srcAddr: swift.SILValue, _ destAddr: swift.SILValue, _ isTake: swift.IsTake_t, _ isInitialize: swift.IsInitialization_t) -> UnsafeMutablePointer<swift.CopyAddrInst>!
    mutating func createBindMemory(_ Loc: swift.SILLocation, _ base: swift.SILValue, _ index: swift.SILValue, _ boundType: swift.SILType) -> UnsafeMutablePointer<swift.BindMemoryInst>!
    mutating func createConvertFunction(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType, _ WithoutActuallyEscaping: Bool) -> UnsafeMutablePointer<swift.ConvertFunctionInst>!
    mutating func createConvertEscapeToNoEscape(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType, _ lifetimeGuaranteed: Bool) -> UnsafeMutablePointer<swift.ConvertEscapeToNoEscapeInst>!
    mutating func createThinFunctionToPointer(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ThinFunctionToPointerInst>!
    mutating func createPointerToThinFunction(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.PointerToThinFunctionInst>!
    mutating func createUpcast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UpcastInst>!
    mutating func createAddressToPointer(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.AddressToPointerInst>!
    mutating func createPointerToAddress(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType, _ isStrict: Bool, _ isInvariant: Bool) -> UnsafeMutablePointer<swift.PointerToAddressInst>!
    mutating func createUncheckedRefCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedRefCastInst>!
    mutating func createUncheckedRefCastAddr(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ sourceFormalType: swift.CanType, _ dest: swift.SILValue, _ targetFormalType: swift.CanType) -> UnsafeMutablePointer<swift.UncheckedRefCastAddrInst>!
    mutating func createUncheckedAddrCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedAddrCastInst>!
    mutating func createUncheckedTrivialBitCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedTrivialBitCastInst>!
    mutating func createUncheckedBitwiseCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedBitwiseCastInst>!
    mutating func createUncheckedValueCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedValueCastInst>!
    mutating func createRefToBridgeObject(_ Loc: swift.SILLocation, _ Ref: swift.SILValue, _ Bits: swift.SILValue) -> UnsafeMutablePointer<swift.RefToBridgeObjectInst>!
    mutating func createBridgeObjectToRef(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.BridgeObjectToRefInst>!
    mutating func createValueToBridgeObject(_ Loc: swift.SILLocation, _ value: swift.SILValue) -> UnsafeMutablePointer<swift.ValueToBridgeObjectInst>!
    mutating func createBridgeObjectToWord(_ Loc: swift.SILLocation, _ Op: swift.SILValue) -> UnsafeMutablePointer<swift.BridgeObjectToWordInst>!
    mutating func createBridgeObjectToWord(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.BridgeObjectToWordInst>!
    mutating func createRefToRawPointer(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.RefToRawPointerInst>!
    mutating func createRawPointerToRef(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.RawPointerToRefInst>!
    mutating func createThinToThickFunction(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ThinToThickFunctionInst>!
    mutating func createThickToObjCMetatype(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ThickToObjCMetatypeInst>!
    mutating func createObjCToThickMetatype(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ObjCToThickMetatypeInst>!
    mutating func createObjCProtocol(_ Loc: swift.SILLocation, _ P: UnsafeMutablePointer<swift.ProtocolDecl>!, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ObjCProtocolInst>!
    mutating func createCopyValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.CopyValueInst>!
    mutating func createDestroyValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestroyValueInst>!
    mutating func createUnconditionalCheckedCast(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ destLoweredTy: swift.SILType, _ destFormalTy: swift.CanType) -> UnsafeMutablePointer<swift.UnconditionalCheckedCastInst>!
    mutating func createUnconditionalCheckedCastAddr(_ Loc: swift.SILLocation, _ src: swift.SILValue, _ sourceFormalType: swift.CanType, _ dest: swift.SILValue, _ targetFormalType: swift.CanType) -> UnsafeMutablePointer<swift.UnconditionalCheckedCastAddrInst>!
    mutating func createUnconditionalCheckedCastValue(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ srcFormalTy: swift.CanType, _ destLoweredTy: swift.SILType, _ destFormalTy: swift.CanType) -> UnsafeMutablePointer<swift.UnconditionalCheckedCastValueInst>!
    mutating func createRetainValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.RetainValueInst>!
    mutating func createRetainValueAddr(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.RetainValueAddrInst>!
    mutating func createReleaseValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.ReleaseValueInst>!
    mutating func createReleaseValueAddr(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.ReleaseValueAddrInst>!
    mutating func createUnmanagedRetainValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.UnmanagedRetainValueInst>!
    mutating func createUnmanagedReleaseValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.UnmanagedReleaseValueInst>!
    mutating func createAutoreleaseValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.AutoreleaseValueInst>!
    mutating func createUnmanagedAutoreleaseValue(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.UnmanagedAutoreleaseValueInst>!
    mutating func createSetDeallocating(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.SetDeallocatingInst>!
    mutating func createObject(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Elements: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ NumBaseElements: UInt32) -> UnsafeMutablePointer<swift.ObjectInst>!
    mutating func createStruct(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Elements: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.StructInst>!
    mutating func createTuple(_ Loc: swift.SILLocation, _ Ty: swift.SILType, _ Elements: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.TupleInst>!
    mutating func createTuple(_ loc: swift.SILLocation, _ elts: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.TupleInst>!
    mutating func createEnum(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.EnumInst>!

    /// Inject a loadable value into the corresponding optional type.
    mutating func createOptionalSome(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.EnumInst>!

    /// Create the nil value of a loadable optional type.
    mutating func createOptionalNone(_ Loc: swift.SILLocation, _ ty: swift.SILType) -> UnsafeMutablePointer<swift.EnumInst>!
    mutating func createInitEnumDataAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.InitEnumDataAddrInst>!
    mutating func createUncheckedEnumData(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedEnumDataInst>!
    mutating func createUncheckedEnumData(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.UncheckedEnumDataInst>!

    /// Return unchecked_enum_data %Operand, #Optional<T>.some.
    mutating func emitExtractOptionalPayloadOperation(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> swift.SILValue
    mutating func createUncheckedTakeEnumDataAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.UncheckedTakeEnumDataAddrInst>!
    mutating func createUncheckedTakeEnumDataAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.UncheckedTakeEnumDataAddrInst>!
    mutating func createInjectEnumAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Element: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.InjectEnumAddrInst>!
    mutating func createSelectEnum(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType, _ DefaultValue: swift.SILValue, _ CaseValues: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIPN5swift15EnumElementDeclENS3_8SILValueEEEEE, _ CaseCounts: llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIN5swift14ProfileCounterEEEEE, _ DefaultCount: swift.ProfileCounter) -> UnsafeMutablePointer<swift.SelectEnumInst>!
    mutating func createSelectEnumAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType, _ DefaultValue: swift.SILValue, _ CaseValues: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIPN5swift15EnumElementDeclENS3_8SILValueEEEEE, _ CaseCounts: llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIN5swift14ProfileCounterEEEEE, _ DefaultCount: swift.ProfileCounter) -> UnsafeMutablePointer<swift.SelectEnumAddrInst>!
    mutating func createSelectValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType, _ DefaultResult: swift.SILValue, _ CaseValuesAndResults: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIN5swift8SILValueES4_EEEE) -> UnsafeMutablePointer<swift.SelectValueInst>!
    mutating func createTupleExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32, _ ResultTy: swift.SILType) -> UnsafeMutablePointer<swift.TupleExtractInst>!
    mutating func createTupleExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32) -> UnsafeMutablePointer<swift.TupleExtractInst>!
    mutating func createTupleElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32, _ ResultTy: swift.SILType) -> UnsafeMutablePointer<swift.TupleElementAddrInst>!
    mutating func createTupleElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32) -> UnsafeMutablePointer<swift.TupleElementAddrInst>!
    mutating func createStructExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!, _ ResultTy: swift.SILType) -> UnsafeMutablePointer<swift.StructExtractInst>!
    mutating func createStructExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.StructExtractInst>!
    mutating func createStructElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!, _ ResultTy: swift.SILType) -> UnsafeMutablePointer<swift.StructElementAddrInst>!
    mutating func createStructElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.StructElementAddrInst>!
    mutating func createRefElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!, _ ResultTy: swift.SILType, _ IsImmutable: Bool) -> UnsafeMutablePointer<swift.RefElementAddrInst>!
    mutating func createRefElementAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.RefElementAddrInst>!
    mutating func createRefTailAddr(_ Loc: swift.SILLocation, _ Ref: swift.SILValue, _ ResultTy: swift.SILType, _ IsImmutable: Bool) -> UnsafeMutablePointer<swift.RefTailAddrInst>!
    mutating func createDestructureStruct(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestructureStructInst>!
    mutating func createDestructureTuple(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestructureTupleInst>!
    mutating func emitDestructureValueOperation(_ loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.MultipleValueInstruction>!
    mutating func emitDestructureValueOperation(_ loc: swift.SILLocation, _ operand: swift.SILValue, _ result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>)
    mutating func emitDestructureAddressOperation(_ loc: swift.SILLocation, _ operand: swift.SILValue, _ result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>)
    mutating func createClassMethod(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Member: swift.SILDeclRef, _ MethodTy: swift.SILType) -> UnsafeMutablePointer<swift.ClassMethodInst>!
    mutating func createSuperMethod(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Member: swift.SILDeclRef, _ MethodTy: swift.SILType) -> UnsafeMutablePointer<swift.SuperMethodInst>!
    mutating func createObjCMethod(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Member: swift.SILDeclRef, _ MethodTy: swift.SILType) -> UnsafeMutablePointer<swift.ObjCMethodInst>!
    mutating func createObjCSuperMethod(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Member: swift.SILDeclRef, _ MethodTy: swift.SILType) -> UnsafeMutablePointer<swift.ObjCSuperMethodInst>!
    mutating func createWitnessMethod(_ Loc: swift.SILLocation, _ LookupTy: swift.CanType, _ Conformance: swift.ProtocolConformanceRef, _ Member: swift.SILDeclRef, _ MethodTy: swift.SILType) -> UnsafeMutablePointer<swift.WitnessMethodInst>!
    mutating func createOpenExistentialAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ SelfTy: swift.SILType, _ ForAccess: swift.OpenedExistentialAccess) -> UnsafeMutablePointer<swift.OpenExistentialAddrInst>!
    mutating func createOpenExistentialValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ SelfTy: swift.SILType) -> UnsafeMutablePointer<swift.OpenExistentialValueInst>!
    mutating func createOpenExistentialMetatype(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ selfTy: swift.SILType) -> UnsafeMutablePointer<swift.OpenExistentialMetatypeInst>!
    mutating func createOpenExistentialRef(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.OpenExistentialRefInst>!
    mutating func createOpenExistentialBox(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.OpenExistentialBoxInst>!
    mutating func createOpenExistentialBoxValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.OpenExistentialBoxValueInst>!
    mutating func createInitExistentialAddr(_ Loc: swift.SILLocation, _ Existential: swift.SILValue, _ FormalConcreteType: swift.CanType, _ LoweredConcreteType: swift.SILType, _ Conformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE) -> UnsafeMutablePointer<swift.InitExistentialAddrInst>!
    mutating func createInitExistentialValue(_ Loc: swift.SILLocation, _ ExistentialType: swift.SILType, _ FormalConcreteType: swift.CanType, _ Concrete: swift.SILValue, _ Conformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE) -> UnsafeMutablePointer<swift.InitExistentialValueInst>!
    mutating func createInitExistentialMetatype(_ Loc: swift.SILLocation, _ metatype: swift.SILValue, _ existentialType: swift.SILType, _ conformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE) -> UnsafeMutablePointer<swift.InitExistentialMetatypeInst>!
    mutating func createInitExistentialRef(_ Loc: swift.SILLocation, _ ExistentialType: swift.SILType, _ FormalConcreteType: swift.CanType, _ Concrete: swift.SILValue, _ Conformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE) -> UnsafeMutablePointer<swift.InitExistentialRefInst>!
    mutating func createDeinitExistentialAddr(_ Loc: swift.SILLocation, _ Existential: swift.SILValue) -> UnsafeMutablePointer<swift.DeinitExistentialAddrInst>!
    mutating func createDeinitExistentialValue(_ Loc: swift.SILLocation, _ Existential: swift.SILValue) -> UnsafeMutablePointer<swift.DeinitExistentialValueInst>!
    mutating func createProjectBlockStorage(_ Loc: swift.SILLocation, _ Storage: swift.SILValue) -> UnsafeMutablePointer<swift.ProjectBlockStorageInst>!
    mutating func createProjectBlockStorage(_ Loc: swift.SILLocation, _ Storage: swift.SILValue, _ CaptureTy: swift.SILType) -> UnsafeMutablePointer<swift.ProjectBlockStorageInst>!
    mutating func createInitBlockStorageHeader(_ Loc: swift.SILLocation, _ BlockStorage: swift.SILValue, _ InvokeFunction: swift.SILValue, _ BlockType: swift.SILType, _ Subs: swift.SubstitutionMap) -> UnsafeMutablePointer<swift.InitBlockStorageHeaderInst>!
    mutating func createMetatype(_ Loc: swift.SILLocation, _ Metatype: swift.SILType) -> UnsafeMutablePointer<swift.MetatypeInst>!
    mutating func createObjCMetatypeToObject(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ObjCMetatypeToObjectInst>!
    mutating func createObjCExistentialMetatypeToObject(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.ObjCExistentialMetatypeToObjectInst>!
    mutating func createValueMetatype(_ Loc: swift.SILLocation, _ Metatype: swift.SILType, _ Base: swift.SILValue) -> UnsafeMutablePointer<swift.ValueMetatypeInst>!
    mutating func createExistentialMetatype(_ Loc: swift.SILLocation, _ Metatype: swift.SILType, _ Base: swift.SILValue) -> UnsafeMutablePointer<swift.ExistentialMetatypeInst>!
    mutating func createCopyBlock(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.CopyBlockInst>!
    mutating func createCopyBlockWithoutEscaping(_ Loc: swift.SILLocation, _ Block: swift.SILValue, _ Closure: swift.SILValue) -> UnsafeMutablePointer<swift.CopyBlockWithoutEscapingInst>!
    mutating func createStrongRetain(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.StrongRetainInst>!
    mutating func createStrongRelease(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ atomicity: swift.Atomicity) -> UnsafeMutablePointer<swift.StrongReleaseInst>!
    mutating func createEndLifetime(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.EndLifetimeInst>!
    mutating func createUncheckedOwnershipConversion(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Kind: swift.ValueOwnershipKind) -> UnsafeMutablePointer<swift.UncheckedOwnershipConversionInst>!
    mutating func createFixLifetime(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.FixLifetimeInst>!
    mutating func emitFixLifetime(_ Loc: swift.SILLocation, _ Operand: swift.SILValue)
    mutating func createClassifyBridgeObject(_ Loc: swift.SILLocation, _ value: swift.SILValue) -> UnsafeMutablePointer<swift.ClassifyBridgeObjectInst>!
    mutating func createMarkDependence(_ Loc: swift.SILLocation, _ value: swift.SILValue, _ base: swift.SILValue) -> UnsafeMutablePointer<swift.MarkDependenceInst>!
    mutating func createIsUnique(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.IsUniqueInst>!
    mutating func createBeginCOWMutation(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ isNative: Bool) -> UnsafeMutablePointer<swift.BeginCOWMutationInst>!
    mutating func createEndCOWMutation(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ keepUnique: Bool) -> UnsafeMutablePointer<swift.EndCOWMutationInst>!
    mutating func createIsEscapingClosure(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ VerificationType: UInt32) -> UnsafeMutablePointer<swift.IsEscapingClosureInst>!
    mutating func createDeallocStack(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.DeallocStackInst>!
    mutating func createDeallocRef(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ canBeOnStack: Bool) -> UnsafeMutablePointer<swift.DeallocRefInst>!
    mutating func createDeallocPartialRef(_ Loc: swift.SILLocation, _ operand: swift.SILValue, _ metatype: swift.SILValue) -> UnsafeMutablePointer<swift.DeallocPartialRefInst>!
    mutating func createDeallocBox(_ Loc: swift.SILLocation, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.DeallocBoxInst>!
    mutating func createDeallocExistentialBox(_ Loc: swift.SILLocation, _ concreteType: swift.CanType, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.DeallocExistentialBoxInst>!
    mutating func createDeallocValueBuffer(_ Loc: swift.SILLocation, _ valueType: swift.SILType, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.DeallocValueBufferInst>!
    mutating func createDestroyAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestroyAddrInst>!
    mutating func createProjectValueBuffer(_ Loc: swift.SILLocation, _ valueType: swift.SILType, _ operand: swift.SILValue) -> UnsafeMutablePointer<swift.ProjectValueBufferInst>!
    mutating func createProjectBox(_ Loc: swift.SILLocation, _ boxOperand: swift.SILValue, _ index: UInt32) -> UnsafeMutablePointer<swift.ProjectBoxInst>!
    mutating func createProjectExistentialBox(_ Loc: swift.SILLocation, _ valueTy: swift.SILType, _ boxOperand: swift.SILValue) -> UnsafeMutablePointer<swift.ProjectExistentialBoxInst>!

    /// Create the appropriate cast instruction based on result type.
    ///
    /// NOTE: We allow for non-layout compatible casts that shrink the underlying
    /// type we are bit casting!
    mutating func createUncheckedReinterpretCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.SingleValueInstruction>!

    /// Create an appropriate cast instruction based on result type.
    ///
    /// NOTE: This assumes that the input and the result cast are layout
    /// compatible. Reduces to createUncheckedReinterpretCast when ownership is
    /// disabled.
    mutating func createUncheckedBitCast(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> UnsafeMutablePointer<swift.SingleValueInstruction>!
    mutating func createCondFail(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Message: llvm.StringRef, _ Inverted: Bool) -> UnsafeMutablePointer<swift.CondFailInst>!
    mutating func createBuiltinTrap(_ Loc: swift.SILLocation) -> UnsafeMutablePointer<swift.BuiltinInst>!
    mutating func createIndexAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Index: swift.SILValue) -> UnsafeMutablePointer<swift.IndexAddrInst>!
    mutating func createTailAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Count: swift.SILValue, _ ResultTy: swift.SILType) -> UnsafeMutablePointer<swift.TailAddrInst>!
    mutating func createIndexRawPointer(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Index: swift.SILValue) -> UnsafeMutablePointer<swift.IndexRawPointerInst>!
    mutating func createGetAsyncContinuation(_ Loc: swift.SILLocation, _ ResumeType: swift.CanType, _ Throws: Bool) -> UnsafeMutablePointer<swift.GetAsyncContinuationInst>!
    mutating func createGetAsyncContinuationAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ ResumeType: swift.CanType, _ Throws: Bool) -> UnsafeMutablePointer<swift.GetAsyncContinuationAddrInst>!
    mutating func createHopToExecutor(_ Loc: swift.SILLocation, _ Actor: swift.SILValue) -> UnsafeMutablePointer<swift.HopToExecutorInst>!
    mutating func createUnreachable(_ Loc: swift.SILLocation) -> UnsafeMutablePointer<swift.UnreachableInst>!
    mutating func createReturn(_ Loc: swift.SILLocation, _ ReturnValue: swift.SILValue) -> UnsafeMutablePointer<swift.ReturnInst>!
    mutating func createThrow(_ Loc: swift.SILLocation, _ errorValue: swift.SILValue) -> UnsafeMutablePointer<swift.ThrowInst>!
    mutating func createUnwind(_ loc: swift.SILLocation) -> UnsafeMutablePointer<swift.UnwindInst>!
    mutating func createYield(_ loc: swift.SILLocation, _ yieldedValues: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ resumeBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ unwindBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.YieldInst>!
    mutating func createAwaitAsyncContinuation(_ loc: swift.SILLocation, _ continuation: swift.SILValue, _ resumeBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ errorBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.AwaitAsyncContinuationInst>!
    mutating func createCondBranch(_ Loc: swift.SILLocation, _ Cond: swift.SILValue, _ Target1: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Target2: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter) -> UnsafeMutablePointer<swift.CondBranchInst>!
    mutating func createCondBranch(_ Loc: swift.SILLocation, _ Cond: swift.SILValue, _ Target1: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args1: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ Target2: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args2: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter) -> UnsafeMutablePointer<swift.CondBranchInst>!
    mutating func createCondBranch(_ Loc: swift.SILLocation, _ Cond: swift.SILValue, _ Target1: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args1: swift.OperandValueArrayRef, _ Target2: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args2: swift.OperandValueArrayRef, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter) -> UnsafeMutablePointer<swift.CondBranchInst>!
    mutating func createBranch(_ Loc: swift.SILLocation, _ TargetBlock: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.BranchInst>!
    mutating func createBranch(_ Loc: swift.SILLocation, _ TargetBlock: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.BranchInst>!
    mutating func createBranch(_ Loc: swift.SILLocation, _ TargetBlock: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Args: swift.OperandValueArrayRef) -> UnsafeMutablePointer<swift.BranchInst>!
    mutating func createSwitchValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ DefaultBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ CaseBBs: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIN5swift8SILValueEPNS3_13SILBasicBlockEEEEE) -> UnsafeMutablePointer<swift.SwitchValueInst>!
    mutating func createSwitchEnum(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ DefaultBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ CaseBBs: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIPN5swift15EnumElementDeclEPNS3_13SILBasicBlockEEEEE, _ CaseCounts: llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIN5swift14ProfileCounterEEEEE, _ DefaultCount: swift.ProfileCounter) -> UnsafeMutablePointer<swift.SwitchEnumInst>!
    mutating func createSwitchEnumAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ DefaultBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ CaseBBs: llvm.__CxxTemplateInstN4llvm8ArrayRefINSt3__14pairIPN5swift15EnumElementDeclEPNS3_13SILBasicBlockEEEEE, _ CaseCounts: llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIN5swift14ProfileCounterEEEEE, _ DefaultCount: swift.ProfileCounter) -> UnsafeMutablePointer<swift.SwitchEnumAddrInst>!
    mutating func createDynamicMethodBranch(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Member: swift.SILDeclRef, _ HasMethodBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ NoMethodBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.DynamicMethodBranchInst>!
    mutating func createCheckedCastBranch(_ Loc: swift.SILLocation, _ isExact: Bool, _ op: swift.SILValue, _ destLoweredTy: swift.SILType, _ destFormalTy: swift.CanType, _ successBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ failureBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter) -> UnsafeMutablePointer<swift.CheckedCastBranchInst>!
    mutating func createCheckedCastValueBranch(_ Loc: swift.SILLocation, _ op: swift.SILValue, _ srcFormalTy: swift.CanType, _ destLoweredTy: swift.SILType, _ destFormalTy: swift.CanType, _ successBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ failureBB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> UnsafeMutablePointer<swift.CheckedCastValueBranchInst>!
    mutating func createCheckedCastAddrBranch(_ Loc: swift.SILLocation, _ consumption: swift.CastConsumptionKind, _ src: swift.SILValue, _ sourceFormalType: swift.CanType, _ dest: swift.SILValue, _ targetFormalType: swift.CanType, _ successBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ failureBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter) -> UnsafeMutablePointer<swift.CheckedCastAddrBranchInst>!

    /// Returns the default atomicity of the module.
    mutating func getDefaultAtomicity() -> swift.Atomicity

    /// Try to fold a destroy_addr operation into the previous instructions, or
    /// generate an explicit one if that fails.  If this inserts a new
    /// instruction, it returns it, otherwise it returns null.
    mutating func emitDestroyAddrAndFold(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestroyAddrInst>!

    /// Perform a strong_release instruction at the current location, attempting
    /// to fold it locally into nearby retain instructions or emitting an explicit
    /// strong release if necessary.  If this inserts a new instruction, it
    /// returns it, otherwise it returns null.
    mutating func emitStrongReleaseAndFold(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.StrongReleaseInst>!

    /// Emit a release_value instruction at the current location, attempting to
    /// fold it locally into another nearby retain_value instruction.  This
    /// returns the new instruction if it inserts one, otherwise it returns null.
    ///
    /// This instruction doesn't handle strength reduction of release_value into
    /// a noop / strong_release / unowned_release.  For that, use the
    /// emitReleaseValueOperation method below or use the TypeLowering API.
    mutating func emitReleaseValueAndFold(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.ReleaseValueInst>!

    /// Emit a release_value instruction at the current location, attempting to
    /// fold it locally into another nearby retain_value instruction.  This
    /// returns the new instruction if it inserts one, otherwise it returns null.
    ///
    /// This instruction doesn't handle strength reduction of release_value into
    /// a noop / strong_release / unowned_release.  For that, use the
    /// emitReleaseValueOperation method below or use the TypeLowering API.
    mutating func emitDestroyValueAndFold(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestroyValueInst>!

    /// Emit a release_value instruction at the current location, attempting to
    /// fold it locally into another nearby retain_value instruction. Returns a
    /// pointer union initialized with a release value inst if it inserts one,
    /// otherwise returns the retain. It is expected that the caller will remove
    /// the retain_value. This allows for the caller to update any state before
    /// the retain_value is destroyed.
    mutating func emitReleaseValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm12PointerUnionIJPN5swift15RetainValueInstEPNS1_16ReleaseValueInstEEEE

    /// Emit a strong_release instruction at the current location, attempting to
    /// fold it locally into another nearby strong_retain instruction. Returns a
    /// pointer union initialized with a strong_release inst if it inserts one,
    /// otherwise returns the pointer union initialized with the strong_retain. It
    /// is expected that the caller will remove the returned strong_retain. This
    /// allows for the caller to update any state before the release value is
    /// destroyed.
    mutating func emitStrongRelease(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm12PointerUnionIJPN5swift16StrongRetainInstEPNS1_17StrongReleaseInstEEEE

    /// Emit a destroy_addr instruction at \p Loc attempting to fold the
    /// destroy_addr locally into a copy_addr instruction. Returns a pointer union
    /// initialized with the folded copy_addr if the destroy_addr was folded into
    /// a copy_addr. Otherwise, returns the newly inserted destroy_addr.
    mutating func emitDestroyAddr(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm12PointerUnionIJPN5swift12CopyAddrInstEPNS1_15DestroyAddrInstEEEE

    /// Emit a destroy_value instruction at the current location, attempting to
    /// fold it locally into another nearby copy_value instruction. Returns a
    /// pointer union initialized with a destroy_value inst if it inserts one,
    /// otherwise returns the copy_value. It is expected that the caller will
    /// remove the copy_value. This allows for the caller to update any state
    /// before the copy_value is destroyed.
    mutating func emitDestroyValue(_ Loc: swift.SILLocation, _ Operand: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm12PointerUnionIJPN5swift13CopyValueInstEPNS1_16DestroyValueInstEEEE

    /// Convenience function for calling emitCopy on the type lowering
    /// for the non-address value.
    mutating func emitCopyValueOperation(_ Loc: swift.SILLocation, _ v: swift.SILValue) -> swift.SILValue

    /// Convenience function for calling emitCopy on the type lowering
    /// for the non-address value.
    mutating func emitLoweredCopyValueOperation(_ Loc: swift.SILLocation, _ v: swift.SILValue, _ expansionKind: swift.Lowering.TypeLowering.TypeExpansionKind) -> swift.SILValue

    /// Convenience function for calling TypeLowering.emitDestroy on the type
    /// lowering for the non-address value.
    mutating func emitDestroyValueOperation(_ Loc: swift.SILLocation, _ v: swift.SILValue)

    /// Convenience function for calling TypeLowering.emitDestroy on the type
    /// lowering for the non-address value.
    mutating func emitLoweredDestroyValueOperation(_ Loc: swift.SILLocation, _ v: swift.SILValue, _ expansionKind: swift.Lowering.TypeLowering.TypeExpansionKind)

    /// Convenience function for destroying objects and addresses.
    ///
    /// Objects are destroyed using emitDestroyValueOperation and addresses by
    /// emitting destroy_addr.
    mutating func emitDestroyOperation(_ loc: swift.SILLocation, _ v: swift.SILValue)
    mutating func emitTupleExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32, _ ResultTy: swift.SILType) -> swift.SILValue
    mutating func emitTupleExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ FieldNo: UInt32) -> swift.SILValue
    mutating func emitStructExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!, _ ResultTy: swift.SILType) -> swift.SILValue
    mutating func emitStructExtract(_ Loc: swift.SILLocation, _ Operand: swift.SILValue, _ Field: UnsafeMutablePointer<swift.VarDecl>!) -> swift.SILValue
    mutating func emitThickToObjCMetatype(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> swift.SILValue
    mutating func emitObjCToThickMetatype(_ Loc: swift.SILLocation, _ Op: swift.SILValue, _ Ty: swift.SILType) -> swift.SILValue
    mutating func createDifferentiableFunction(_ Loc: swift.SILLocation, _ ParameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ ResultIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ OriginalFunction: swift.SILValue, _ JVPAndVJPFunctions: llvm.__CxxTemplateInstN4llvm8OptionalINSt3__14pairIN5swift8SILValueES4_EEEE) -> UnsafeMutablePointer<swift.DifferentiableFunctionInst>!
    mutating func createLinearFunction(_ Loc: swift.SILLocation, _ ParameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ OriginalFunction: swift.SILValue, _ TransposeFunction: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift8SILValueEEE) -> UnsafeMutablePointer<swift.LinearFunctionInst>!

    /// Note: explicit extractee type may be specified only in lowered SIL.
    mutating func createDifferentiableFunctionExtract(_ Loc: swift.SILLocation, _ Extractee: swift.NormalDifferentiableFunctionTypeComponent, _ Function: swift.SILValue, _ ExtracteeType: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift7SILTypeEEE) -> UnsafeMutablePointer<swift.DifferentiableFunctionExtractInst>!
    mutating func createDifferentiableFunctionExtractOriginal(_ Loc: swift.SILLocation, _ TheFunction: swift.SILValue) -> UnsafeMutablePointer<swift.DifferentiableFunctionExtractInst>!
    mutating func createLinearFunctionExtract(_ Loc: swift.SILLocation, _ Extractee: swift.LinearDifferentiableFunctionTypeComponent, _ TheFunction: swift.SILValue) -> UnsafeMutablePointer<swift.LinearFunctionExtractInst>!

    /// Note: explicit function type may be specified only in lowered SIL.
    mutating func createDifferentiabilityWitnessFunction(_ Loc: swift.SILLocation, _ WitnessKind: swift.DifferentiabilityWitnessFunctionKind, _ Witness: UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!, _ FunctionType: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift7SILTypeEEE) -> UnsafeMutablePointer<swift.DifferentiabilityWitnessFunctionInst>!
  }

  /// An wrapper on top of SILBuilder's constructor that automatically sets the
  /// current SILDebugScope based on the specified insertion point. This is useful
  /// for situations where a single SIL instruction is lowered into a sequence of
  /// SIL instructions.
  struct SILBuilderWithScope {

    /// Build instructions before the given insertion point, inheriting the debug
    /// location.
    ///
    /// Clients should prefer this constructor.
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ C: UnsafeMutablePointer<swift.SILBuilderContext>)

    /// Build instructions before the given insertion point, inheriting the debug
    /// location and using the context from the passed in builder.
    ///
    /// Clients should prefer this constructor.
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ B: UnsafeMutablePointer<swift.SILBuilder>)
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ InsertedInstrs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14SILInstructionEEE>!)
    init(_ I: swift.SILBasicBlock.iterator)
    init(_ I: swift.SILBasicBlock.iterator, _ B: UnsafeMutablePointer<swift.SILBuilder>)
    init(_ I: UnsafeMutablePointer<swift.SILInstruction>!, _ InheritScopeFrom: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ I: swift.SILBasicBlock.iterator, _ InheritScopeFrom: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ InheritScopeFrom: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ B: UnsafeMutablePointer<swift.SILBuilder>, _ InheritScopeFrom: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ C: UnsafeMutablePointer<swift.SILBuilderContext>, _ debugScope: UnsafePointer<swift.SILDebugScope>!)

    /// Creates a new SILBuilder with an insertion point at the
    /// beginning of BB and the debug scope from the first
    /// non-metainstruction in the BB.
    init(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!)

    /// If \p inst is a terminator apply site, then pass a builder to insert at
    /// the first instruction of each successor to \p func. Otherwise, pass a
    /// builder to insert at std::next(inst).
    ///
    /// The intention is that this abstraction will enable the compiler writer to
    /// ignore whether or not \p inst is a terminator when inserting instructions
    /// after \p inst.
    ///
    /// Precondition: It's the responsibility of the caller to ensure that if
    /// \p inst is a terminator, all successor blocks have only a single
    /// predecessor block: the parent of \p inst.
    static func insertAfter(_ inst: UnsafeMutablePointer<swift.SILInstruction>!, _ func: llvm.__CxxTemplateInstN4llvm12function_refIFvRN5swift10SILBuilderEEEE)

    /// If \p is an inst, then this is equivalent to insertAfter(inst). If a
    /// SILArgument is passed in, we use the first instruction in its parent
    /// block. We assert on undef.
    static func insertAfter(_ value: swift.SILValue, _ func: llvm.__CxxTemplateInstN4llvm12function_refIFvRN5swift10SILBuilderEEEE)
  }
  struct SavedInsertionPointRAII {

    /// Constructor that saves a Builder's insertion point without changing the
    /// builder's underlying insertion point.
    init(_ B: UnsafeMutablePointer<swift.SILBuilder>)
    init(_ b: UnsafeMutablePointer<swift.SILBuilder>, _ insertionPoint: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ b: UnsafeMutablePointer<swift.SILBuilder>, _ block: UnsafeMutablePointer<swift.SILBasicBlock>!, _ iter: swift.SILBasicBlock.iterator)
    init(_ b: UnsafeMutablePointer<swift.SILBuilder>, _ insertionBlock: UnsafeMutablePointer<swift.SILBasicBlock>!)
  }

  /// Apply a debug location override for the duration of the current scope.
  struct DebugLocOverrideRAII {
    init(_ B: UnsafeMutablePointer<swift.SILBuilder>, _ Loc: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11SILLocationEEE)
  }

  /// SILOpenedArchetypesTracker is a helper class that can be used to create
  /// and maintain a mapping from opened archetypes to instructions
  /// defining them, e.g. open_existential_ref, open_existential_addr,
  /// open_existential_metatype.
  ///
  /// This information is useful for representing and maintaining the
  /// dependencies of instructions on opened archetypes they are using.
  ///
  /// The intended clients of this class are SILGen, SIL deserializers, etc.
  struct SILOpenedArchetypesTracker {
    typealias OpenedArchetypeDefsMap = llvm.__CxxTemplateInstN4llvm8DenseMapIPN5swift13ArchetypeTypeEPNS1_22SingleValueInstructionENS_12DenseMapInfoIS3_EENS_6detail12DenseMapPairIS3_S5_EEEE
    init(_ F: UnsafePointer<swift.SILFunction>!, _ Tracker: UnsafeMutablePointer<swift.SILOpenedArchetypesTracker>)
    init(_ F: UnsafePointer<swift.SILFunction>!, _ OpenedArchetypeDefs: UnsafeMutablePointer<swift.SILOpenedArchetypesTracker.OpenedArchetypeDefsMap>)
    init(_ F: UnsafePointer<swift.SILFunction>!)
    mutating func getFunction() -> UnsafePointer<swift.SILFunction>!
    mutating func getOpenedArchetypeDefs() -> UnsafePointer<swift.SILOpenedArchetypesTracker.OpenedArchetypeDefsMap>
    mutating func registerOpenedArchetypes(_ I: UnsafePointer<swift.SILInstruction>!) -> Bool
    mutating func registerUsedOpenedArchetypes(_ I: UnsafePointer<swift.SILInstruction>!) -> Bool
    mutating func registerUsedOpenedArchetypes(_ Ty: swift.CanType) -> Bool
    mutating func unregisterOpenedArchetypes(_ I: UnsafePointer<swift.SILInstruction>!)
    mutating func hasUnresolvedOpenedArchetypeDefinitions() -> Bool
    mutating func needsNotifications() -> Bool
    mutating func handleDeleteNotification(_ node: UnsafeMutablePointer<swift.SILNode>!)
    mutating func dump()
  }
  struct SILOpenedArchetypesState {
    init(_ Tracker: UnsafePointer<swift.SILOpenedArchetypesTracker>!)
    init(_ Tracker: UnsafePointer<swift.SILOpenedArchetypesTracker>)
    mutating func setOpenedArchetypesTracker(_ Tracker: UnsafePointer<swift.SILOpenedArchetypesTracker>!)
    mutating func addOpenedArchetypeOperands(_ Operands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE)
    mutating func getOpenedArchetypesTracker() -> UnsafePointer<swift.SILOpenedArchetypesTracker>!
    mutating func dump()
  }
  struct SILArgument {
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind
    mutating func setOwnershipKind(_ newKind: swift.ValueOwnershipKind)
    mutating func getParent() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getFunction() -> UnsafePointer<swift.SILFunction>!
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getDecl() -> UnsafePointer<swift.ValueDecl>!
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    mutating func getIndex() -> UInt32

    /// Return true if this block argument is actually a phi argument as
    /// opposed to a cast or projection.
    mutating func isPhiArgument() -> Bool

    /// If this argument is a phi, return the incoming phi value for the given
    /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
    mutating func getIncomingPhiValue(_ predBlock: UnsafeMutablePointer<swift.SILBasicBlock>!) -> swift.SILValue

    /// If this argument is a phi, populate `OutArray` with the incoming phi
    /// values for each predecessor BB. If this argument is not a phi, return
    /// false.
    mutating func getIncomingPhiValues(_ returnedPhiValues: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>) -> Bool

    /// If this argument is a phi, populate `OutArray` with each predecessor block
    /// and its incoming phi value. If this argument is not a phi, return false.
    mutating func getIncomingPhiValues(_ returnedPredAndPhiValuePairs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplINSt3__14pairIPN5swift13SILBasicBlockENS3_8SILValueEEEEE>) -> Bool

    /// If this argument is a true phi, for each operand in each predecessor block
    /// associated with an incoming value, call visitor(op). Visitor must return
    /// true for iteration to continue. False to stop it.
    ///
    /// Returns false if this is not a true phi or that a visitor signaled error
    /// by returning false.
    mutating func visitIncomingPhiOperands(_ visitor: llvm.__CxxTemplateInstN4llvm12function_refIFbPN5swift7OperandEEEE) -> Bool

    /// Returns true if we were able to find a single terminator operand value for
    /// each predecessor of this arguments basic block. The found values are
    /// stored in OutArray.
    ///
    /// Note: this peeks through any projections or cast implied by the
    /// terminator. e.g. the incoming value for a switch_enum payload argument is
    /// the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperands(_ returnedSingleTermOperands: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>) -> Bool

    /// Returns true if we were able to find single terminator operand values for
    /// each predecessor of this arguments basic block. The found values are
    /// stored in OutArray alongside their predecessor block.
    ///
    /// Note: this peeks through any projections or cast implied by the
    /// terminator. e.g. the incoming value for a switch_enum payload argument is
    /// the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperands(_ returnedSingleTermOperands: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplINSt3__14pairIPN5swift13SILBasicBlockENS3_8SILValueEEEEE>) -> Bool

    /// If this SILArgument's parent block has a single predecessor whose
    /// terminator has a single operand, return the incoming operand of the
    /// predecessor's terminator. Returns SILValue() otherwise.  Note that for
    /// some predecessor terminators the incoming value is not exactly the
    /// argument value. E.g. the incoming value for a switch_enum payload argument
    /// is the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperand() -> swift.SILValue

    /// If this SILArgument's parent block has a single predecessor whose
    /// terminator has a single operand, return that terminator.
    mutating func getSingleTerminator() -> UnsafeMutablePointer<swift.TermInst>!

    /// Return the SILArgumentKind of this argument.
    mutating func getKind() -> swift.SILArgumentKind
  }
  struct SILUndef {
    static func get(_ ty: swift.SILType, _ m: UnsafeMutablePointer<swift.SILModule>) -> UnsafeMutablePointer<swift.SILUndef>!
    static func get(_ ty: swift.SILType, _ f: UnsafePointer<swift.SILFunction>) -> UnsafeMutablePointer<swift.SILUndef>!
    static func getSentinelValue<OwnerTy>(_ type: swift.SILType, _ owner: OwnerTy) -> UnsafeMutablePointer<swift.SILUndef>!
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct SILArgumentKind {
    struct innerty : Equatable, RawRepresentable {
      init(_ rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift9ValueKindELb1EEE.type)
      init(rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift9ValueKindELb1EEE.type)
      var rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift9ValueKindELb1EEE.type
      typealias RawValue = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift9ValueKindELb1EEE.type
    }
    var value: swift.SILArgumentKind.innerty
    init(_ kind: swift.ValueKind)
    init(_ value: swift.SILArgumentKind.innerty)
    static func fromValueKind(_ kind: swift.ValueKind) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift15SILArgumentKindEEE
  }
  struct SILPhiArgument {

    /// Return true if this is block argument is actually a phi argument as
    /// opposed to a cast or projection.
    mutating func isPhiArgument() -> Bool

    /// If this argument is a phi, return the incoming phi value for the given
    /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
    ///
    /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
    /// this will be guaranteed to return a valid SILValue.
    mutating func getIncomingPhiValue(_ predBlock: UnsafeMutablePointer<swift.SILBasicBlock>!) -> swift.SILValue

    /// If this argument is a phi, populate `OutArray` with the incoming phi
    /// values for each predecessor BB. If this argument is not a phi, return
    /// false.
    ///
    /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
    /// this will always succeed.
    mutating func getIncomingPhiValues(_ returnedPhiValues: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>) -> Bool

    /// If this argument is a phi, populate `OutArray` with each predecessor block
    /// and its incoming phi value. If this argument is not a phi, return false.
    ///
    /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
    /// this will always succeed.
    mutating func getIncomingPhiValues(_ returnedPredAndPhiValuePairs: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplINSt3__14pairIPN5swift13SILBasicBlockENS3_8SILValueEEEEE>) -> Bool

    /// If this argument is a phi, call visitor for each passing the operand for
    /// each incoming phi values for each predecessor BB. If this argument is not
    /// a phi, return false.
    ///
    /// If visitor returns false, iteration is stopped and we return false.
    mutating func visitIncomingPhiOperands(_ visitor: llvm.__CxxTemplateInstN4llvm12function_refIFbPN5swift7OperandEEEE) -> Bool

    /// Returns true if we were able to find a single terminator operand value for
    /// each predecessor of this arguments basic block. The found values are
    /// stored in OutArray.
    ///
    /// Note: this peeks through any projections or cast implied by the
    /// terminator. e.g. the incoming value for a switch_enum payload argument is
    /// the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperands(_ returnedSingleTermOperands: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>) -> Bool

    /// Returns true if we were able to find single terminator operand values for
    /// each predecessor of this arguments basic block. The found values are
    /// stored in OutArray alongside their predecessor block.
    ///
    /// Note: this peeks through any projections or cast implied by the
    /// terminator. e.g. the incoming value for a switch_enum payload argument is
    /// the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperands(_ returnedSingleTermOperands: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplINSt3__14pairIPN5swift13SILBasicBlockENS3_8SILValueEEEEE>) -> Bool

    /// If this SILArgument's parent block has a single predecessor whose
    /// terminator has a single operand, return the incoming operand of the
    /// predecessor's terminator. Returns SILValue() otherwise.  Note that for
    /// some predecessor terminators the incoming value is not exactly the
    /// argument value. E.g. the incoming value for a switch_enum payload argument
    /// is the enum itself (the operand of the switch_enum).
    mutating func getSingleTerminatorOperand() -> swift.SILValue

    /// If this SILArgument's parent block has a single predecessor whose
    /// terminator has a single operand, return that terminator.
    mutating func getSingleTerminator() -> UnsafeMutablePointer<swift.TermInst>!
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct SILFunctionArgument {
    mutating func isIndirectResult() -> Bool
    mutating func getArgumentConvention() -> swift.SILArgumentConvention

    /// Given that this is an entry block argument, and given that it does
    /// not correspond to an indirect result, return the corresponding
    /// SILParameterInfo.
    mutating func getKnownParameterInfo() -> swift.SILParameterInfo

    /// Returns true if this SILArgument is the self argument of its
    /// function. This means that this will return false always for SILArguments
    /// of SILFunctions that do not have self argument and for non-function
    /// argument SILArguments.
    mutating func isSelf() -> Bool

    /// Returns true if this SILArgument is passed via the given convention.
    mutating func hasConvention(_ convention: swift.SILArgumentConvention) -> Bool
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// The base class for all SIL-level transformations.
  struct SILTransform {

    /// The kind of transformation passes we use.
    enum TransformKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case Function
      case Module
    }

    /// Stores the kind of derived class.
    var Kind: swift.SILTransform.TransformKind { get }

    /// C'tor. \p K indicates the kind of derived class.
    init(_ K: swift.SILTransform.TransformKind)

    /// Returns the kind of derived class.
    mutating func getKind() -> swift.SILTransform.TransformKind

    /// Returns the pass kind.
    mutating func getPassKind() -> swift.PassKind

    /// Sets the pass kind. This should only be done in the add-functions of
    /// the pass manager.
    mutating func setPassKind(_ newPassKind: swift.PassKind)

    /// Inject the pass manager running this pass.
    mutating func injectPassManager(_ PMM: UnsafeMutablePointer<swift.SILPassManager>!)
    mutating func getPassManager() -> UnsafeMutablePointer<swift.SILPassManager>!
    mutating func getIRGenModule() -> OpaquePointer!

    /// Get the transform's (command-line) tag.
    mutating func getTag() -> llvm.StringRef

    /// Get the transform's name as a C++ identifier.
    mutating func getID() -> llvm.StringRef
  }

  /// A transformation that operates on functions.
  struct SILFunctionTransform {

    /// C'tor.
    init()

    /// The entry point to the transformation.
    mutating func run()
    static func classof(_ S: UnsafePointer<swift.SILTransform>!) -> Bool
    mutating func injectFunction(_ Func: UnsafeMutablePointer<swift.SILFunction>!)

    /// Notify the pass manager of a function \p F that needs to be
    /// processed by the function passes and the analyses.
    ///
    /// If not null, the function \p DerivedFrom is the function from which \p F
    /// is derived. This is used to limit the number of new functions which are
    /// derived from a common base function, e.g. due to specialization.
    /// The number should be small anyway, but bugs in optimizations could cause
    /// an infinite loop in the passmanager.
    mutating func addFunctionToPassManagerWorklist(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ DerivedFrom: UnsafeMutablePointer<swift.SILFunction>!)

    /// Reoptimize the current function by restarting the pass
    /// pipeline on it.
    mutating func restartPassPipeline()
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func invalidateAnalysis(_ K: swift.SILAnalysis.InvalidationKind)
  }

  /// A transformation that operates on modules.
  struct SILModuleTransform {

    /// C'tor.
    init()

    /// The entry point to the transformation.
    mutating func run()
    static func classof(_ S: UnsafePointer<swift.SILTransform>!) -> Bool
    mutating func injectModule(_ Mod: UnsafeMutablePointer<swift.SILModule>!)
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>!

    /// Invalidate all analysis data for the whole module.
    mutating func invalidateAll()

    /// Invalidate only the function \p F, using invalidation information \p K.
    mutating func invalidateAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ K: swift.SILAnalysis.InvalidationKind)

    /// Invalidate the analysis data for witness- and vtables.
    mutating func invalidateFunctionTables()

    /// Inform the pass manager that we are going to delete a function.
    mutating func notifyWillDeleteFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)
  }
  struct SILOptions {
    struct AssertConfiguration : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }

    /// Controls the aggressiveness of the performance inliner.
    var InlineThreshold: Int32

    /// Controls the aggressiveness of the performance inliner for Osize.
    var CallerBaseBenefitReductionFactor: Int32

    /// Controls the aggressiveness of the loop unroller.
    var UnrollThreshold: Int32

    /// Remove all runtime assertions during optimizations.
    var RemoveRuntimeAsserts: Bool

    /// Controls whether the SIL ARC optimizations are run.
    var EnableARCOptimizations: Bool

    /// Controls whether specific OSSA optimizations are run. For benchmarking
    /// purposes.
    var EnableOSSAOptimizations: Bool

    /// Controls whether to turn on speculative devirtualization.
    /// It is turned off by default.
    var EnableSpeculativeDevirtualization: Bool

    /// Should we run any SIL performance optimizations
    ///
    /// Useful when you want to enable -O LLVM opts but not -O SIL opts.
    var DisableSILPerfOptimizations: Bool

    /// Controls whether cross module optimization is enabled.
    var CrossModuleOptimization: Bool

    /// Controls whether or not paranoid verification checks are run.
    var VerifyAll: Bool

    /// If true, no SIL verification is done at all.
    var VerifyNone: Bool

    /// Are we debugging sil serialization.
    var DebugSerialization: Bool

    /// Whether to dump verbose SIL with scope and location information.
    var EmitVerboseSIL: Bool

    /// Should we sort SIL functions, vtables, witness tables, and global
    /// variables by name when we print it out. This eases diffing of SIL files.
    var EmitSortedSIL: Bool

    /// See \ref FrontendOptions.PrintFullConvention
    var PrintFullConvention: Bool

    /// Whether to stop the optimization pipeline after serializing SIL.
    var StopOptimizationAfterSerialization: Bool

    /// Whether to stop the optimization pipeline right before we lower ownership
    /// and go from OSSA to non-ownership SIL.
    var StopOptimizationBeforeLoweringOwnership: Bool
    var SkipFunctionBodies: swift.FunctionBodySkipping

    /// Optimization mode being used.
    var OptMode: swift.OptimizationMode

    /// The assert configuration controls how assertions behave.
    var AssertConfig: UInt32

    /// Should we print out instruction counts if -print-stats is passed in?
    var PrintInstCounts: Bool

    /// Instrument code to generate profiling information.
    var GenerateProfile: Bool

    /// Emit a mapping of profile counters for use in coverage.
    var EmitProfileCoverageMapping: Bool

    /// Should we use a pass pipeline passed in via a json file? Null by default.
    var ExternalPassPipelineFilename: llvm.StringRef

    /// Don't generate code using partial_apply in SIL generation.
    var DisableSILPartialApply: Bool

    /// If set to true, compile with the SIL Ownership Model enabled.
    var VerifySILOwnership: Bool

    /// Assume that code will be executed in a single-threaded environment.
    var AssumeSingleThreaded: Bool

    /// Turn @inline(__always) attributes into no-ops.
    ///
    /// For experimentation around code size reduction.
    var IgnoreAlwaysInline: Bool

    /// Indicates which sanitizer is turned on.
    var Sanitizers: swift.__CxxTemplateInstN5swift9OptionSetINS_13SanitizerKindEjEE

    /// Emit compile-time diagnostics when the law of exclusivity is violated.
    var EnforceExclusivityStatic: Bool

    /// Emit checks to trap at run time when the law of exclusivity is violated.
    var EnforceExclusivityDynamic: Bool

    /// Emit extra exclusvity markers for memory access and verify coverage.
    var VerifyExclusivity: Bool

    /// Calls to the replaced method inside of the replacement method will call
    /// the previous implementation.
    ///
    /// @_dynamicReplacement(for: original())
    /// func replacement() {
    ///   if (...)
    ///     original() // calls original() implementation if true
    /// }
    var EnableDynamicReplacementCanCallPreviousImplementation: Bool

    /// Enable large loadable types IRGen pass.
    var EnableLargeLoadableTypes: Bool

    /// The format used for serializing remarks (default: YAML)
    var OptRecordFormat: llvm.remarks.Format
    init()

    /// Return a hash code of any components from these options that should
    /// contribute to a Swift Bridging PCH hash.
    mutating func getPCHHashComponents() -> llvm.hash_code
    mutating func shouldOptimize() -> Bool
  }

  /// The main entrypoint for executing a pipeline pass on a SIL module.
  static func executePassPipelinePlan(_ SM: UnsafeMutablePointer<swift.SILModule>!, _ plan: UnsafePointer<swift.SILPassPipelinePlan>, _ isMandatory: Bool, _ IRMod: OpaquePointer!)

  /// The SIL pass manager.
  struct SILPassManager {
    mutating func getOptions() -> UnsafePointer<swift.SILOptions>

    /// Searches for an analysis of type T in the list of registered
    /// analysis. If the analysis is not found, the program terminates.
    mutating func getAnalysis<T>() -> OpaquePointer!

    /// \returns the module that the pass manager owns.
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>!

    /// \returns the associated IGenModule or null if this is not an IRGen
    /// pass manager.
    mutating func getIRGenModule() -> OpaquePointer!

    /// Restart the function pass pipeline on the same function
    /// that is currently being processed.
    mutating func restartWithCurrentFunction(_ T: UnsafeMutablePointer<swift.SILTransform>!)
    mutating func clearRestartPipeline()
    mutating func shouldRestartPipeline() -> Bool

    /// Iterate over all analysis and invalidate them.
    mutating func invalidateAllAnalysis()

    /// Notify the pass manager of a newly create function for tracing.
    mutating func notifyOfNewFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ T: UnsafeMutablePointer<swift.SILTransform>!)

    /// Add the function \p F to the function pass worklist.
    /// If not null, the function \p DerivedFrom is the function from which \p F
    /// is derived. This is used to avoid an infinite amount of functions pushed
    /// on the worklist (e.g. caused by a bug in a specializing optimization).
    mutating func addFunctionToWorklist(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ DerivedFrom: UnsafeMutablePointer<swift.SILFunction>!)

    /// Iterate over all analysis and notify them of the function.
    ///
    /// This function does not necessarily have to be newly created function. It
    /// is the job of the analysis to make sure no extra work is done if the
    /// particular analysis has been done on the function.
    mutating func notifyAnalysisOfFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Broadcast the invalidation of the function to all analysis.
    mutating func invalidateAnalysis(_ F: UnsafeMutablePointer<swift.SILFunction>!, _ K: swift.SILAnalysis.InvalidationKind)

    /// Iterate over all analysis and notify them of a change in witness-
    /// or vtables.
    mutating func invalidateFunctionTables()

    /// Iterate over all analysis and notify them of a deleted function.
    mutating func notifyWillDeleteFunction(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Reset the state of the pass manager and remove all transformation
    /// owned by the pass manager. Analysis passes will be kept.
    mutating func resetAndRemoveTransformations()

    /// Set the name of the current optimization stage.
    ///
    /// This is useful for debugging.
    mutating func setStageName(_ NextStage: llvm.StringRef)

    /// Get the name of the current optimization stage.
    ///
    /// This is useful for debugging.
    mutating func getStageName() -> llvm.StringRef

    /// Verify all analyses.
    mutating func verifyAnalyses()

    /// Precompute all analyses.
    mutating func forcePrecomputeAnalyses(_ F: UnsafeMutablePointer<swift.SILFunction>!)

    /// Verify all analyses, limiting the verification to just this one function
    /// if possible.
    ///
    /// Discussion: We leave it up to the analyses to decide how to implement
    /// this. If no override is provided the SILAnalysis should just call the
    /// normal verify method.
    mutating func verifyAnalyses(_ F: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func executePassPipelinePlan(_ Plan: UnsafePointer<swift.SILPassPipelinePlan>)
  }
  struct SILPassPipelinePlan {
    typealias PipelineKindIterator = std.__1.__CxxTemplateInstNSt3__16vectorIN5swift8PassKindENS_9allocatorIS2_EEEE.const_iterator
    typealias PipelineKindRange = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPKN5swift8PassKindEEEEE
    typealias PipelineIterator = std.__1.__CxxTemplateInstNSt3__16vectorIN5swift15SILPassPipelineENS_9allocatorIS2_EEEE.const_iterator
    typealias PipelineRange = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPKN5swift15SILPassPipelineEEEEE
    init(_ Options: UnsafePointer<swift.SILOptions>)
    mutating func getOptions() -> UnsafePointer<swift.SILOptions>
    mutating func addAADumper()
    mutating func addABCOpt()
    mutating func addAccessEnforcementDom()
    mutating func addAccessEnforcementOpts()
    mutating func addAccessEnforcementReleaseSinking()
    mutating func addAccessEnforcementSelection()
    mutating func addAccessEnforcementWMO()
    mutating func addCrossModuleSerializationSetup()
    mutating func addAccessSummaryDumper()
    mutating func addAccessedStorageAnalysisDumper()
    mutating func addAccessPathVerification()
    mutating func addAccessedStorageDumper()
    mutating func addAccessMarkerElimination()
    mutating func addAddressLowering()
    mutating func addAllocBoxToStack()
    mutating func addAllocStackHoisting()
    mutating func addArrayCountPropagation()
    mutating func addArrayElementPropagation()
    mutating func addAssumeSingleThreaded()
    mutating func addBasicInstructionPropertyDumper()
    mutating func addBasicCalleePrinter()
    mutating func addCFGPrinter()
    mutating func addCOWArrayOpts()
    mutating func addCSE()
    mutating func addCallerAnalysisPrinter()
    mutating func addCapturePromotion()
    mutating func addCapturePropagation()
    mutating func addClosureSpecializer()
    mutating func addClosureLifetimeFixup()
    mutating func addCodeSinking()
    mutating func addComputeDominanceInfo()
    mutating func addComputeLoopInfo()
    mutating func addConditionForwarding()
    mutating func addConstantEvaluatorTester()
    mutating func addConstantEvaluableSubsetChecker()
    mutating func addCopyForwarding()
    mutating func addCopyPropagation()
    mutating func addCOWOpts()
    mutating func addDifferentiation()
    mutating func addEpilogueARCMatcherDumper()
    mutating func addEpilogueRetainReleaseMatcherDumper()
    mutating func addRedundantOverflowCheckRemoval()
    mutating func addDCE()
    mutating func addDeadArgSignatureOpt()
    mutating func addDeadFunctionElimination()
    mutating func addDeadObjectElimination()
    mutating func addDefiniteInitialization()
    mutating func addDestroyHoisting()
    mutating func addDevirtualizer()
    mutating func addDiagnoseInfiniteRecursion()
    mutating func addDiagnoseInvalidEscapingCaptures()
    mutating func addDiagnoseStaticExclusivity()
    mutating func addDiagnoseUnreachable()
    mutating func addDiagnosticConstantPropagation()
    mutating func addDifferentiabilityWitnessDevirtualizer()
    mutating func addEagerSpecializer()
    mutating func addOnonePrespecializations()
    mutating func addEarlyCodeMotion()
    mutating func addEarlyInliner()
    mutating func addEmitDFDiagnostics()
    mutating func addEscapeAnalysisDumper()
    mutating func addFunctionOrderPrinter()
    mutating func addFunctionSignatureOpts()
    mutating func addARCSequenceOpts()
    mutating func addARCLoopOpts()
    mutating func addEarlyRedundantLoadElimination()
    mutating func addRedundantLoadElimination()
    mutating func addDeadStoreElimination()
    mutating func addGenericSpecializer()
    mutating func addExistentialSpecializer()
    mutating func addSILSkippingChecker()
    mutating func addGlobalOpt()
    mutating func addGlobalPropertyOpt()
    mutating func addGuaranteedARCOpts()
    mutating func addHighLevelCSE()
    mutating func addHighLevelLICM()
    mutating func addIVInfoPrinter()
    mutating func addOptimizeHopToExecutor()
    mutating func addInstCount()
    mutating func addJumpThreadSimplifyCFG()
    mutating func addLetPropertiesOpt()
    mutating func addLICM()
    mutating func addLateCodeMotion()
    mutating func addLateDeadFunctionElimination()
    mutating func addLateInliner()
    mutating func addLoopCanonicalizer()
    mutating func addLoopInfoPrinter()
    mutating func addLoopRegionViewText()
    mutating func addLoopRegionViewCFG()
    mutating func addLoopRotate()
    mutating func addLoopUnroll()
    mutating func addLowerAggregateInstrs()
    mutating func addMandatoryInlining()
    mutating func addMem2Reg()
    mutating func addMemBehaviorDumper()
    mutating func addLSLocationPrinter()
    mutating func addMergeCondFails()
    mutating func addMoveCondFailToPreds()
    mutating func addNoReturnFolding()
    mutating func addObjectOutliner()
    mutating func addOutliner()
    mutating func addOwnershipModelEliminator()
    mutating func addNestedSemanticFunctionCheck()
    mutating func addNonTransparentFunctionOwnershipModelEliminator()
    mutating func addNonStdlibNonTransparentFunctionOwnershipModelEliminator()
    mutating func addRCIdentityDumper()
    mutating func addAlwaysInlineInliner()
    mutating func addPerfInliner()
    mutating func addPerformanceConstantPropagation()
    mutating func addPredictableMemoryAccessOptimizations()
    mutating func addPredictableDeadAllocationElimination()
    mutating func addRedundantPhiElimination()
    mutating func addPhiExpansion()
    mutating func addReleaseDevirtualizer()
    mutating func addRetainSinking()
    mutating func addReleaseHoisting()
    mutating func addLateReleaseHoisting()
    mutating func addLoadableByAddress()
    mutating func addMandatorySILLinker()
    mutating func addPerformanceSILLinker()
    mutating func addRawSILInstLowering()
    mutating func addTempLValueOpt()
    mutating func addTempRValueOpt()
    mutating func addSideEffectsDumper()
    mutating func addIRGenPrepare()
    mutating func addSILGenCleanup()
    mutating func addSILCombine()
    mutating func addSILDebugInfoGenerator()
    mutating func addEarlySROA()
    mutating func addSROA()
    mutating func addSROABBArgs()
    mutating func addSimplifyBBArgs()
    mutating func addSimplifyCFG()
    mutating func addSpeculativeDevirtualization()
    mutating func addSplitAllCriticalEdges()
    mutating func addSplitNonCondBrCriticalEdges()
    mutating func addStackPromotion()
    mutating func addStripDebugInfo()
    mutating func addStringOptimization()
    mutating func addSwiftArrayPropertyOpt()
    mutating func addUnsafeGuaranteedPeephole()
    mutating func addUsePrespecialized()
    mutating func addOwnershipDumper()
    mutating func addOwnershipVerifierTextualErrorDumper()
    mutating func addSemanticARCOpts()
    mutating func addSimplifyUnreachableContainingBlocks()
    mutating func addSerializeSILPass()
    mutating func addCMOSerializeSILPass()
    mutating func addYieldOnceCheck()
    mutating func addOSLogOptimization()
    mutating func addForEachLoopUnroll()
    mutating func addMandatoryCombine()
    mutating func addBugReducerTester()
    mutating func addOptRemarkGenerator()
    mutating func addPruneVTables()
    static func getDiagnosticPassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getOwnershipEliminatorPassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getPerformancePassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getOnonePassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getInstCountPassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getLoweringPassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getIRGenPreparePassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getSerializeSILPassPipeline(_ Options: UnsafePointer<swift.SILOptions>) -> swift.SILPassPipelinePlan
    static func getPassPipelineFromFile(_ Options: UnsafePointer<swift.SILOptions>, _ Filename: llvm.StringRef) -> swift.SILPassPipelinePlan

    /// Our general format is as follows:
    ///
    ///   [
    ///     [
    ///       "PASS_MANAGER_ID",
    ///       "one_iteration"|"until_fix_point",
    ///       "PASS1", "PASS2", ...
    ///     ],
    ///   ...
    ///   ]
    mutating func dump()
    @warn_unqualified_access
    mutating func print(_ os: UnsafeMutablePointer<llvm.raw_ostream>)
    mutating func startPipeline(_ Name: llvm.StringRef, _ isFunctionPassPipeline: Bool)
    mutating func getPipelinePasses(_ P: UnsafePointer<swift.SILPassPipeline>) -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPKN5swift8PassKindEEEEE
    mutating func getPipelines() -> swift.SILPassPipelinePlan.PipelineRange
  }
  struct SILPassPipeline {
    var ID: UInt32
    var Name: llvm.StringRef
    var KindOffset: UInt32
    var isFunctionPassPipeline: Bool
    init()
  }
  enum PassPipelineKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case Diagnostic
    case OwnershipEliminator
    case Performance
    case Onone
    case InstCount
    case Lowering
    case IRGenPrepare
    case SerializeSIL
  }

  /// Run all the SIL diagnostic passes on \p M.
  ///
  /// \returns true if the diagnostic passes produced an error
  static func runSILDiagnosticPasses(_ M: UnsafeMutablePointer<swift.SILModule>) -> Bool

  /// Run all the SIL performance optimization passes on \p M.
  static func runSILOptimizationPasses(_ M: UnsafeMutablePointer<swift.SILModule>)

  /// Run all SIL passes for -Onone on module \p M.
  static func runSILPassesForOnone(_ M: UnsafeMutablePointer<swift.SILModule>)

  /// Run the SIL ownership eliminator pass on \p M.
  static func runSILOwnershipEliminatorPass(_ M: UnsafeMutablePointer<swift.SILModule>) -> Bool
  static func runSILOptimizationPassesWithFileSpecification(_ Module: UnsafeMutablePointer<swift.SILModule>, _ FileName: llvm.StringRef)

  /// Detect and remove unreachable code. Diagnose provably unreachable
  /// user code.
  static func performSILDiagnoseUnreachable(_ M: UnsafeMutablePointer<swift.SILModule>!)

  /// Remove dead functions from \p M.
  static func performSILDeadFunctionElimination(_ M: UnsafeMutablePointer<swift.SILModule>!)

  /// Convert SIL to a lowered form suitable for IRGen.
  static func runSILLoweringPasses(_ M: UnsafeMutablePointer<swift.SILModule>)

  /// Perform SIL Inst Count on M if needed.
  static func performSILInstCountIfNeeded(_ M: UnsafeMutablePointer<swift.SILModule>!)

  /// Identifiers for all passes. Used to procedurally create passes from
  /// lists of passes.
  enum PassKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case AADumper
    case ABCOpt
    case AccessEnforcementDom
    case AccessEnforcementOpts
    case AccessEnforcementReleaseSinking
    case AccessEnforcementSelection
    case AccessEnforcementWMO
    case CrossModuleSerializationSetup
    case AccessSummaryDumper
    case AccessedStorageAnalysisDumper
    case AccessPathVerification
    case AccessedStorageDumper
    case AccessMarkerElimination
    case AddressLowering
    case AllocBoxToStack
    case AllocStackHoisting
    case ArrayCountPropagation
    case ArrayElementPropagation
    case AssumeSingleThreaded
    case BasicInstructionPropertyDumper
    case BasicCalleePrinter
    case CFGPrinter
    case COWArrayOpts
    case CSE
    case CallerAnalysisPrinter
    case CapturePromotion
    case CapturePropagation
    case ClosureSpecializer
    case ClosureLifetimeFixup
    case CodeSinking
    case ComputeDominanceInfo
    case ComputeLoopInfo
    case ConditionForwarding
    case ConstantEvaluatorTester
    case ConstantEvaluableSubsetChecker
    case CopyForwarding
    case CopyPropagation
    case COWOpts
    case Differentiation
    case EpilogueARCMatcherDumper
    case EpilogueRetainReleaseMatcherDumper
    case RedundantOverflowCheckRemoval
    case DCE
    case DeadArgSignatureOpt
    case DeadFunctionElimination
    case DeadObjectElimination
    case DefiniteInitialization
    case DestroyHoisting
    case Devirtualizer
    case DiagnoseInfiniteRecursion
    case DiagnoseInvalidEscapingCaptures
    case DiagnoseStaticExclusivity
    case DiagnoseUnreachable
    case DiagnosticConstantPropagation
    case DifferentiabilityWitnessDevirtualizer
    case EagerSpecializer
    case OnonePrespecializations
    case EarlyCodeMotion
    case EarlyInliner
    case EmitDFDiagnostics
    case EscapeAnalysisDumper
    case FunctionOrderPrinter
    case FunctionSignatureOpts
    case ARCSequenceOpts
    case ARCLoopOpts
    case EarlyRedundantLoadElimination
    case RedundantLoadElimination
    case DeadStoreElimination
    case GenericSpecializer
    case ExistentialSpecializer
    case SILSkippingChecker
    case GlobalOpt
    case GlobalPropertyOpt
    case GuaranteedARCOpts
    case HighLevelCSE
    case HighLevelLICM
    case IVInfoPrinter
    case OptimizeHopToExecutor
    case InstCount
    case JumpThreadSimplifyCFG
    case LetPropertiesOpt
    case LICM
    case LateCodeMotion
    case LateDeadFunctionElimination
    case LateInliner
    case LoopCanonicalizer
    case LoopInfoPrinter
    case LoopRegionViewText
    case LoopRegionViewCFG
    case LoopRotate
    case LoopUnroll
    case LowerAggregateInstrs
    case MandatoryInlining
    case Mem2Reg
    case MemBehaviorDumper
    case LSLocationPrinter
    case MergeCondFails
    case MoveCondFailToPreds
    case NoReturnFolding
    case ObjectOutliner
    case Outliner
    case OwnershipModelEliminator
    case NestedSemanticFunctionCheck
    case NonTransparentFunctionOwnershipModelEliminator
    case NonStdlibNonTransparentFunctionOwnershipModelEliminator
    case RCIdentityDumper
    case AlwaysInlineInliner
    case PerfInliner
    case PerformanceConstantPropagation
    case PredictableMemoryAccessOptimizations
    case PredictableDeadAllocationElimination
    case RedundantPhiElimination
    case PhiExpansion
    case ReleaseDevirtualizer
    case RetainSinking
    case ReleaseHoisting
    case LateReleaseHoisting
    case LoadableByAddress
    case MandatorySILLinker
    case PerformanceSILLinker
    case RawSILInstLowering
    case TempLValueOpt
    case TempRValueOpt
    case SideEffectsDumper
    case IRGenPrepare
    case SILGenCleanup
    case SILCombine
    case SILDebugInfoGenerator
    case EarlySROA
    case SROA
    case SROABBArgs
    case SimplifyBBArgs
    case SimplifyCFG
    case SpeculativeDevirtualization
    case SplitAllCriticalEdges
    case SplitNonCondBrCriticalEdges
    case StackPromotion
    case StripDebugInfo
    case StringOptimization
    case SwiftArrayPropertyOpt
    case UnsafeGuaranteedPeephole
    case UsePrespecialized
    case OwnershipDumper
    case OwnershipVerifierTextualErrorDumper
    case SemanticARCOpts
    case SimplifyUnreachableContainingBlocks
    case SerializeSILPass
    case CMOSerializeSILPass
    case YieldOnceCheck
    case OSLogOptimization
    case ForEachLoopUnroll
    case MandatoryCombine
    case BugReducerTester
    case OptRemarkGenerator
    case PruneVTables
    static var AllPasses_First: swift.PassKind { get }
    static var AllPasses_Last: swift.PassKind { get }
    case invalidPassKind
  }
  static func PassKindFromString(_ ID: llvm.StringRef) -> swift.PassKind
  static func PassKindID(_ Kind: swift.PassKind) -> llvm.StringRef
  static func PassKindTag(_ Kind: swift.PassKind) -> llvm.StringRef
  static func createAADumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createABCOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessEnforcementDom() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessEnforcementOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessEnforcementReleaseSinking() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessEnforcementSelection() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessEnforcementWMO() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCrossModuleSerializationSetup() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessSummaryDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessedStorageAnalysisDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessPathVerification() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessedStorageDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAccessMarkerElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAddressLowering() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAllocBoxToStack() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createArrayCountPropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createArrayElementPropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAssumeSingleThreaded() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createBasicInstructionPropertyDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createBasicCalleePrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCFGPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCOWArrayOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCSE() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCallerAnalysisPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCapturePromotion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCapturePropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createClosureSpecializer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createClosureLifetimeFixup() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCodeSinking() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createComputeDominanceInfo() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createComputeLoopInfo() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createConditionForwarding() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createConstantEvaluatorTester() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createConstantEvaluableSubsetChecker() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCopyForwarding() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCopyPropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCOWOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDifferentiation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEpilogueARCMatcherDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEpilogueRetainReleaseMatcherDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRedundantOverflowCheckRemoval() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDCE() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDeadArgSignatureOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDeadFunctionElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDeadObjectElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDefiniteInitialization() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDestroyHoisting() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDevirtualizer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDiagnoseInfiniteRecursion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDiagnoseInvalidEscapingCaptures() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDiagnoseStaticExclusivity() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDiagnoseUnreachable() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDiagnosticConstantPropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDifferentiabilityWitnessDevirtualizer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEagerSpecializer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOnonePrespecializations() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEarlyCodeMotion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEarlyInliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEmitDFDiagnostics() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEscapeAnalysisDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createFunctionOrderPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createFunctionSignatureOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createARCSequenceOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createARCLoopOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEarlyRedundantLoadElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRedundantLoadElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createDeadStoreElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createGenericSpecializer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createExistentialSpecializer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSILSkippingChecker() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createGlobalOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createGlobalPropertyOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createGuaranteedARCOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createHighLevelCSE() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createHighLevelLICM() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createIVInfoPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOptimizeHopToExecutor() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createInstCount() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createJumpThreadSimplifyCFG() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLetPropertiesOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLICM() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLateCodeMotion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLateDeadFunctionElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLateInliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopCanonicalizer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopInfoPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopRegionViewText() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopRegionViewCFG() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopRotate() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLoopUnroll() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLowerAggregateInstrs() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMandatoryInlining() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMem2Reg() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMemBehaviorDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLSLocationPrinter() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMergeCondFails() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMoveCondFailToPreds() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createNoReturnFolding() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createObjectOutliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOutliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOwnershipModelEliminator() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createNestedSemanticFunctionCheck() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createNonTransparentFunctionOwnershipModelEliminator() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createNonStdlibNonTransparentFunctionOwnershipModelEliminator() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRCIdentityDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createAlwaysInlineInliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPerfInliner() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPerformanceConstantPropagation() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPredictableMemoryAccessOptimizations() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPredictableDeadAllocationElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRedundantPhiElimination() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPhiExpansion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createReleaseDevirtualizer() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRetainSinking() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createReleaseHoisting() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createLateReleaseHoisting() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMandatorySILLinker() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPerformanceSILLinker() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createRawSILInstLowering() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createTempLValueOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createTempRValueOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSideEffectsDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createIRGenPrepare() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSILGenCleanup() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSILCombine() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSILDebugInfoGenerator() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createEarlySROA() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSROA() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSROABBArgs() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSimplifyBBArgs() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSimplifyCFG() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSpeculativeDevirtualization() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSplitAllCriticalEdges() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSplitNonCondBrCriticalEdges() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createStackPromotion() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createStripDebugInfo() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createStringOptimization() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSwiftArrayPropertyOpt() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createUnsafeGuaranteedPeephole() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createUsePrespecialized() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOwnershipDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOwnershipVerifierTextualErrorDumper() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSemanticARCOpts() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSimplifyUnreachableContainingBlocks() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createSerializeSILPass() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createCMOSerializeSILPass() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createYieldOnceCheck() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOSLogOptimization() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createForEachLoopUnroll() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createMandatoryCombine() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createBugReducerTester() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createOptRemarkGenerator() -> UnsafeMutablePointer<swift.SILTransform>!
  static func createPruneVTables() -> UnsafeMutablePointer<swift.SILTransform>!

  /// AnyFunctionType - A function type has zero or more input parameters and a
  /// single result. The result type may be a tuple. For example:
  ///   "(int) -> int" or "(a : int, b : int) -> (int, int)".
  ///
  /// There are two kinds of function types:  monomorphic (FunctionType) and
  /// polymorphic (GenericFunctionType). Both type families additionally can
  /// be 'thin', indicating that a function value has no capture context and can be
  /// represented at the binary level as a single function pointer.
  struct AnyFunctionType {
    typealias Representation = swift.FunctionTypeRepresentation
    struct Param {
      init(_ t: swift.`Type`, _ l: swift.Identifier, _ f: swift.ParameterTypeFlags)

      /// FIXME: Remove this. Return the formal type of the parameter in the
      /// function type, including the InOutType if there is one.
      ///
      /// For example, 'inout Int' => 'inout Int', 'Int...' => 'Int'.
      mutating func getOldType() -> swift.`Type`

      /// Return the formal type of the parameter.
      ///
      /// For example, 'inout Int' => 'Int', 'Int...' => 'Int'.
      mutating func getPlainType() -> swift.`Type`

      /// The type of the parameter when referenced inside the function body
      /// as an rvalue.
      ///
      /// For example, 'inout Int' => 'Int', 'Int...' => '[Int]'.
      mutating func getParameterType(_ forCanonical: Bool, _ ctx: UnsafeMutablePointer<swift.ASTContext>!) -> swift.`Type`
      mutating func hasLabel() -> Bool
      mutating func getLabel() -> swift.Identifier
      mutating func getParameterFlags() -> swift.ParameterTypeFlags

      /// Whether the parameter is varargs
      mutating func isVariadic() -> Bool

      /// Whether the parameter is marked '@autoclosure'
      mutating func isAutoClosure() -> Bool

      /// Whether the parameter is marked 'inout'
      mutating func isInOut() -> Bool

      /// Whether the parameter is marked 'shared'
      mutating func isShared() -> Bool

      /// Whether the parameter is marked 'owned'
      mutating func isOwned() -> Bool

      /// Whether the parameter is marked '@_nonEphemeral'
      mutating func isNonEphemeral() -> Bool

      /// Whether the parameter is marked '@noDerivative'.
      mutating func isNoDerivative() -> Bool
      mutating func getValueOwnership() -> swift.ValueOwnership
      static func == (lhs: inout swift.AnyFunctionType.Param, b: UnsafePointer<swift.AnyFunctionType.Param>) -> Bool
      static func != (lhs: inout swift.AnyFunctionType.Param, b: UnsafePointer<swift.AnyFunctionType.Param>) -> Bool
      mutating func getWithoutLabel() -> swift.AnyFunctionType.Param
      mutating func withLabel(_ newLabel: swift.Identifier) -> swift.AnyFunctionType.Param
      mutating func withType(_ newType: swift.`Type`) -> swift.AnyFunctionType.Param
      mutating func withFlags(_ flags: swift.ParameterTypeFlags) -> swift.AnyFunctionType.Param
    }
    struct CanParam {
      static func getFromParam(_ param: UnsafePointer<swift.AnyFunctionType.Param>) -> swift.AnyFunctionType.CanParam
      mutating func getOldType() -> swift.CanType
      mutating func getPlainType() -> swift.CanType
      mutating func getParameterType() -> swift.CanType
    }
    typealias ExtInfo = swift.ASTExtInfo
    typealias ExtInfoBuilder = swift.ASTExtInfoBuilder
    typealias CanParamArrayRef = swift.__CxxTemplateInstN5swift12ArrayRefViewINS_15AnyFunctionType5ParamENS1_8CanParamEL_ZNS3_12getFromParamERKS2_ELb1EEE
    struct Yield {
      init(_ type: swift.`Type`, _ flags: swift.YieldTypeFlags)
      mutating func getType() -> swift.`Type`
      mutating func getFlags() -> swift.YieldTypeFlags
      mutating func getValueOwnership() -> swift.ValueOwnership
      mutating func isInOut() -> Bool
      mutating func getCanonical() -> swift.AnyFunctionType.CanYield

      /// There are a number of places where it's convenient to re-use
      /// the call machinery, processing yields as if they were
      /// parameters of a call.  Return this reinterpreted as a parameter.
      mutating func asParam() -> swift.AnyFunctionType.Param
      mutating func subst(_ subs: swift.SubstitutionMap, _ options: swift.SubstOptions) -> swift.AnyFunctionType.Yield
      static func == (lhs: inout swift.AnyFunctionType.Yield, other: UnsafePointer<swift.AnyFunctionType.Yield>) -> Bool
      static func != (lhs: inout swift.AnyFunctionType.Yield, other: UnsafePointer<swift.AnyFunctionType.Yield>) -> Bool
    }
    struct CanYield {
      init(_ type: swift.CanType, _ flags: swift.YieldTypeFlags)
      mutating func getType() -> swift.CanType
      mutating func asParam() -> swift.AnyFunctionType.CanParam
      mutating func subst(_ subs: swift.SubstitutionMap, _ options: swift.SubstOptions) -> swift.AnyFunctionType.CanYield
    }

    /// Take an array of parameters and turn it into an input type.
    ///
    /// The result type is only there as a way to extract the ASTContext when
    /// needed.
    static func composeInput(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ params: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE, _ canonicalVararg: Bool) -> swift.`Type`
    static func composeInput(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ params: swift.AnyFunctionType.CanParamArrayRef, _ canonicalVararg: Bool) -> swift.`Type`

    /// Given two arrays of parameters determine if they are equal.
    static func equalParams(_ a: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE, _ b: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE) -> Bool

    /// Given two arrays of parameters determine if they are equal.
    static func equalParams(_ a: swift.AnyFunctionType.CanParamArrayRef, _ b: swift.AnyFunctionType.CanParamArrayRef) -> Bool
    mutating func getResult() -> swift.`Type`
    mutating func getParams() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE
    mutating func getNumParams() -> UInt32
    mutating func getOptGenericSignature() -> swift.GenericSignature
    mutating func hasClangTypeInfo() -> Bool
    mutating func getClangTypeInfo() -> swift.ClangTypeInfo
    mutating func getCanonicalClangTypeInfo() -> swift.ClangTypeInfo

    /// Returns true if the function type stores a Clang type that cannot
    /// be derived from its Swift type. Returns false otherwise, including if
    /// the function type is not @convention(c) or @convention(block).
    ///
    /// For example, if you have a function pointer from C getting imported with
    /// the following type:
    ///
    /// @convention(c, cType: "void (*)(size_t (*)(size_t))")
    ///   (@convention(c, cType: "size_t (*)(size_t)") (Int) -> Int)) -> Void
    ///
    /// The parameter's function type will have hasNonDerivableClangType() = true,
    /// but the outer function type will have hasNonDerivableClangType() = false,
    /// because the parameter and result type are sufficient to correctly derive
    /// the Clang type for the outer function type. In terms of mangling,
    /// the parameter type's mangling will incorporate the Clang type but the
    /// outer function type's mangling doesn't need to duplicate that information.
    mutating func hasNonDerivableClangType() -> Bool
    mutating func getExtInfo() -> swift.AnyFunctionType.ExtInfo

    /// Get the canonical ExtInfo for the function type.
    ///
    /// The parameter useClangFunctionType is present only for staging purposes.
    /// In the future, we will always use the canonical clang function type.
    mutating func getCanonicalExtInfo(_ useClangFunctionType: Bool) -> swift.AnyFunctionType.ExtInfo
    mutating func hasSameExtInfoAs(_ otherFn: UnsafePointer<swift.AnyFunctionType>!) -> Bool

    /// Get the representation of the function type.
    mutating func getRepresentation() -> swift.AnyFunctionType.Representation

    /// Returns the derivative function type for the given parameter indices,
    /// result index, derivative function kind, derivative function generic
    /// signature (optional), and other auxiliary parameters.
    ///
    /// Preconditions:
    /// - Parameters corresponding to parameter indices must conform to
    ///   `Differentiable`.
    /// - There is one semantic function result type: either the formal original
    ///   result or an `inout` parameter. It must conform to `Differentiable`.
    ///
    /// Typing rules, given:
    /// - Original function type. Three cases:
    ///   - Top-level function: `(T0, T1, ...) -> R`
    ///   - Static method: `(Self.Type) -> (T0, T1, ...) -> R`
    ///   - Instance method: `(Self) -> (T0, T1, ...) -> R`
    ///
    /// Terminology:
    /// - The derivative of a `Differentiable`-conforming type has the
    ///   `TangentVector` associated type. `TangentVector` is abbreviated as `Tan`
    ///   below.
    /// - "wrt" parameters refers to differentiability parameters, identified by
    ///   the parameter indices.
    /// - "wrt" result refers to the result identified by the result index.
    ///
    /// JVP derivative type:
    /// - Takes original parameters.
    /// - Returns original result, followed by a differential function, which
    ///   takes "wrt" parameter derivatives and returns a "wrt" result derivative.
    ///
    /// \verbatim
    ///   (T0, T1, ...) -> (R,       (T0.Tan, T1.Tan, ...) -> R.Tan)
    ///                     ^         ^~~~~~~~~~~~~~~~~~~     ^~~~~
    ///           original result | derivatives wrt params | derivative wrt result
    ///
    ///   (Self) -> (T0, ...) -> (R, (Self.Tan, T0.Tan, ...) -> R.Tan)
    ///                           ^   ^~~~~~~~~~~~~~~~~~~~~     ^~~~~
    ///             original result  |  deriv. wrt params  |  deriv. wrt result
    /// \endverbatim
    ///
    /// VJP derivative type:
    /// - Takes original parameters.
    /// - Returns original result, followed by a pullback function, which
    ///   takes a "wrt" result derivative and returns "wrt" parameter derivatives.
    ///
    /// \verbatim
    ///   (T0, T1, ...) -> (R,           (R.Tan)    ->     (T0.Tan, T1.Tan, ...))
    ///                     ^             ^~~~~             ^~~~~~~~~~~~~~~~~~~
    ///          original result | derivative wrt result | derivatives wrt params
    ///
    ///   (Self) -> (T0, ...) -> (R,     (R.Tan)    ->    (Self.Tan, T0.Tan, ...))
    ///                           ^       ^~~~~            ^~~~~~~~~~~~~~~~~~~~~
    ///              original result | deriv. wrt result | deriv. wrt params
    /// \endverbatim
    ///
    /// The original type may have `inout` parameters. If so, the
    /// differential/pullback typing rules are more nuanced: see documentation for
    /// `getAutoDiffDerivativeFunctionLinearMapType` for details. Semantically,
    /// `inout` parameters behave as both parameters and results.
    ///
    /// By default, if the original type has a `self` parameter list and parameter
    /// indices include `self`, the computed derivative function type will return
    /// a linear map taking/returning self's tangent *last* instead of first, for
    /// consistency with SIL.
    ///
    /// If `makeSelfParamFirst` is true, `self`'s tangent is reordered to appear
    /// first. `makeSelfParamFirst` should be true when working with user-facing
    /// derivative function types, e.g. when type-checking `@differentiable` and
    /// `@derivative` attributes.
    mutating func getAutoDiffDerivativeFunctionType(_ parameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ kind: swift.AutoDiffDerivativeFunctionKind, _ lookupConformance: swift.LookupConformanceFn, _ derivativeGenericSignature: swift.GenericSignature, _ makeSelfParamFirst: Bool) -> UnsafeMutablePointer<swift.AnyFunctionType>!
    mutating func getWithoutDifferentiability() -> UnsafeMutablePointer<swift.AnyFunctionType>!

    /// True if the parameter declaration it is attached to is guaranteed
    /// to not persist the closure for longer than the duration of the call.
    mutating func isNoEscape() -> Bool
    mutating func isAsync() -> Bool
    mutating func isThrowing() -> Bool
    mutating func isDifferentiable() -> Bool
    mutating func getDifferentiabilityKind() -> swift.DifferentiabilityKind

    /// Returns a new function type exactly like this one but with the ExtInfo
    /// replaced.
    mutating func withExtInfo(_ info: swift.AnyFunctionType.ExtInfo) -> UnsafeMutablePointer<swift.AnyFunctionType>!
    static func printParams(_ Params: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE, _ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ PO: UnsafePointer<swift.PrintOptions>)
    static func classof(_ T: UnsafePointer<swift.TypeBase>!) -> Bool
  }

  /// ASTContext - This object creates and owns the AST objects.
  /// However, this class does more than just maintain context within an AST.
  /// It is the closest thing to thread-local or compile-local storage in this
  /// code base. Why? SourceKit uses this code with multiple threads per Unix
  /// process. Each thread processes a different source file. Each thread has its
  /// own instance of ASTContext, and that instance persists for the duration of
  /// the thread, throughout all phases of the compilation. (The name "ASTContext"
  /// is a bit of a misnomer here.) Why not use thread-local storage? This code
  /// may use DispatchQueues and pthread-style TLS won't work with code that uses
  /// DispatchQueues. Summary: if you think you need a global or static variable,
  /// you probably need to put it here instead.
  struct ASTContext {

    /// A callback used to produce a diagnostic for an ill-formed protocol
    /// conformance that was type-checked before we're actually walking the
    /// conformance itself, along with a bit indicating whether this diagnostic
    /// produces an error.
    struct DelayedConformanceDiag {
      var Requirement: UnsafeMutablePointer<swift.ValueDecl>!
      var Callback: std.__1.__CxxTemplateInstNSt3__18functionIFvvEEE
      var IsError: Bool
      init()
      init(Requirement: UnsafeMutablePointer<swift.ValueDecl>!, Callback: std.__1.__CxxTemplateInstNSt3__18functionIFvvEEE, IsError: Bool)
    }
    enum OverrideGenericSignatureReqCheck : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32

      /// Base method's generic requirements are satisifed by derived method
      case BaseReqSatisfiedByDerived

      /// Derived method's generic requirements are satisifed by base method
      case DerivedReqSatisfiedByBase
    }

    /// Optional table of counters to report, nullptr when not collecting.
    ///
    /// This must be initialized early so that Allocate() doesn't try to access
    /// it before being set to null.
    var Stats: UnsafeMutablePointer<swift.UnifiedStatsReporter>!

    /// The language options used for translation.
    var LangOpts: UnsafePointer<swift.LangOptions>

    /// The type checker options.
    var TypeCheckerOpts: UnsafePointer<swift.TypeCheckerOptions>

    /// The search path options used by this AST context.
    var SearchPathOpts: UnsafeMutablePointer<swift.SearchPathOptions>

    /// The clang importer options used by this AST context.
    var ClangImporterOpts: UnsafeMutablePointer<swift.ClangImporterOptions>

    /// The source manager object.
    var SourceMgr: UnsafeMutablePointer<swift.SourceManager>

    /// Diags - The diagnostics engine.
    var Diags: UnsafeMutablePointer<swift.DiagnosticEngine>
    var CompletionCallback: OpaquePointer!

    /// The request-evaluator that is used to process various requests.
    var evaluator: swift.Evaluator

    /// The builtin module.
    var TheBuiltinModule: UnsafeMutablePointer<swift.ModuleDecl>! { get }

    /// The standard library module.
    var TheStdlibModule: UnsafeMutablePointer<swift.ModuleDecl>!

    /// The name of the standard library module "Swift".
    var StdlibModuleName: swift.Identifier

    /// The name of the SwiftShims module "SwiftShims".
    var SwiftShimsModuleName: swift.Identifier
    var Id_AllCases: swift.Identifier
    var Id_allCases: swift.Identifier
    var Id_alloc: swift.Identifier
    var Id_allocWithZone: swift.Identifier
    var Id_allZeros: swift.Identifier
    var Id_Any: swift.Identifier
    var Id_ArrayLiteralElement: swift.Identifier
    var Id_atIndexedSubscript: swift.Identifier
    var Id_bridgeToObjectiveC: swift.Identifier
    var Id_buildArray: swift.Identifier
    var Id_buildBlock: swift.Identifier
    var Id_buildEither: swift.Identifier
    var Id_buildExpression: swift.Identifier
    var Id_buildFinalResult: swift.Identifier
    var Id_buildIf: swift.Identifier
    var Id_buildLimitedAvailability: swift.Identifier
    var Id_buildOptional: swift.Identifier
    var Id_callAsFunction: swift.Identifier
    var Id_Change: swift.Identifier
    var Id_code_: swift.Identifier
    var Id_CodingKeys: swift.Identifier
    var Id_combine: swift.Identifier
    var Id_Concurrency: swift.Identifier
    var Id_container: swift.Identifier
    var Id_CoreGraphics: swift.Identifier
    var Id_CoreMedia: swift.Identifier
    var Id_CGFloat: swift.Identifier
    var Id_CoreFoundation: swift.Identifier
    var Id_CVarArg: swift.Identifier
    var Id_Darwin: swift.Identifier
    var Id_dealloc: swift.Identifier
    var Id_Decodable: swift.Identifier
    var Id_decode: swift.Identifier
    var Id_decodeIfPresent: swift.Identifier
    var Id_Decoder: swift.Identifier
    var Id_decoder: swift.Identifier
    var Id_Differentiation: swift.Identifier
    var Id_dynamicallyCall: swift.Identifier
    var Id_dynamicMember: swift.Identifier
    var Id_Element: swift.Identifier
    var Id_enclosingInstance: swift.Identifier
    var Id_Encodable: swift.Identifier
    var Id_encode: swift.Identifier
    var Id_encodeIfPresent: swift.Identifier
    var Id_Encoder: swift.Identifier
    var Id_encoder: swift.Identifier
    var Id_enqueue: swift.Identifier
    var Id_erasing: swift.Identifier
    var Id_error: swift.Identifier
    var Id_errorDomain: swift.Identifier
    var Id_first: swift.Identifier
    var Id_forKeyedSubscript: swift.Identifier
    var Id_Foundation: swift.Identifier
    var Id_for: swift.Identifier
    var Id_forKey: swift.Identifier
    var Id_from: swift.Identifier
    var Id_fromRaw: swift.Identifier
    var Id_hash: swift.Identifier
    var Id_hasher: swift.Identifier
    var Id_hashValue: swift.Identifier
    var Id_initialize: swift.Identifier
    var Id_initStorage: swift.Identifier
    var Id_initialValue: swift.Identifier
    var Id_into: swift.Identifier
    var Id_intValue: swift.Identifier
    var Id_Key: swift.Identifier
    var Id_KeyedDecodingContainer: swift.Identifier
    var Id_KeyedEncodingContainer: swift.Identifier
    var Id_keyedBy: swift.Identifier
    var Id_keyPath: swift.Identifier
    var Id_makeIterator: swift.Identifier
    var Id_Iterator: swift.Identifier
    var Id_load: swift.Identifier
    var Id_main: swift.Identifier
    var Id_MainEntryPoint: swift.Identifier
    var Id_next: swift.Identifier
    var Id_nsErrorDomain: swift.Identifier
    var Id_objectAtIndexedSubscript: swift.Identifier
    var Id_objectForKeyedSubscript: swift.Identifier
    var Id_ObjectiveC: swift.Identifier
    var Id_ObjectiveCType: swift.Identifier
    var Id_oldValue: swift.Identifier
    var Id_Optional: swift.Identifier
    var Id_OptionalNilComparisonType: swift.Identifier
    var Id_parameter: swift.Identifier
    var Id_partialTask: swift.Identifier
    var Id_PartialAsyncTask: swift.Identifier
    var Id_projected: swift.Identifier
    var Id_projectedValue: swift.Identifier
    var Id_Protocol: swift.Identifier
    var Id_rawValue: swift.Identifier
    var Id_RawValue: swift.Identifier
    var Id_second: swift.Identifier
    var Id_Selector: swift.Identifier
    var Id_self: swift.Identifier
    var Id_Self: swift.Identifier
    var Id_setObject: swift.Identifier
    var Id_shared: swift.Identifier
    var Id_simd: swift.Identifier
    var Id_storage: swift.Identifier
    var Id_stringValue: swift.Identifier
    var Id_super: swift.Identifier
    var Id_superDecoder: swift.Identifier
    var Id_superEncoder: swift.Identifier
    var Id_SwiftObject: swift.Identifier
    var Id_SwiftNativeNSObject: swift.Identifier
    var Id_to: swift.Identifier
    var Id_toRaw: swift.Identifier
    var Id_Type: swift.Identifier
    var Id_type: swift.Identifier
    var Id_Value: swift.Identifier
    var Id_value: swift.Identifier
    var Id_value_: swift.Identifier
    var Id_Void: swift.Identifier
    var Id_WinSDK: swift.Identifier
    var Id_with: swift.Identifier
    var Id_withArguments: swift.Identifier
    var Id_withKeywordArguments: swift.Identifier
    var Id_wrapped: swift.Identifier
    var Id_wrappedValue: swift.Identifier
    var Id_wrapperValue: swift.Identifier
    var Id_UnknownLayout: swift.Identifier
    var Id_TrivialLayout: swift.Identifier
    var Id_TrivialAtMostLayout: swift.Identifier
    var Id_RefCountedObjectLayout: swift.Identifier
    var Id_NativeRefCountedObjectLayout: swift.Identifier
    var Id_ClassLayout: swift.Identifier
    var Id_NativeClassLayout: swift.Identifier
    var Id_MatchOperator: swift.Identifier
    var Id_LessThanOperator: swift.Identifier
    var Id_EqualsOperator: swift.Identifier
    var Id_NegationOperator: swift.Identifier
    var Id_derived_enum_less_than: swift.Identifier
    var Id_derived_enum_equals: swift.Identifier
    var Id_derived_struct_equals: swift.Identifier
    var Id_AssignmentPrecedence: swift.Identifier
    var Id_CastingPrecedence: swift.Identifier
    var Id_DefaultPrecedence: swift.Identifier
    var Id_FunctionArrowPrecedence: swift.Identifier
    var Id_NilCoalescingPrecedence: swift.Identifier
    var Id_TernaryPrecedence: swift.Identifier
    var Id_MaxBuiltinIntegerType: swift.Identifier
    var Id_IntegerLiteralType: swift.Identifier
    var Id_nilLiteral: swift.Identifier
    var Id_integerLiteral: swift.Identifier
    var Id_builtinIntegerLiteral: swift.Identifier
    var Id_MaxBuiltinFloatType: swift.Identifier
    var Id_FloatLiteralType: swift.Identifier
    var Id_floatLiteral: swift.Identifier
    var Id_builtinFloatLiteral: swift.Identifier
    var Id_BooleanLiteralType: swift.Identifier
    var Id_builtinBooleanLiteral: swift.Identifier
    var Id_booleanLiteral: swift.Identifier
    var Id_ExtendedGraphemeClusterLiteralType: swift.Identifier
    var Id_builtinExtendedGraphemeClusterLiteral: swift.Identifier
    var Id_extendedGraphemeClusterLiteral: swift.Identifier
    var Id_UnicodeScalarLiteralType: swift.Identifier
    var Id_builtinUnicodeScalarLiteral: swift.Identifier
    var Id_unicodeScalarLiteral: swift.Identifier
    var Id_stringLiteral: swift.Identifier
    var Id_builtinStringLiteral: swift.Identifier
    var Id_StringLiteralType: swift.Identifier
    var Id_stringInterpolation: swift.Identifier
    var Id_StringInterpolation: swift.Identifier
    var Id_literalCapacity: swift.Identifier
    var Id_interpolationCount: swift.Identifier
    var Id_appendLiteral: swift.Identifier
    var Id_appendInterpolation: swift.Identifier
    var Id_dollarInterpolation: swift.Identifier
    var Id_arrayLiteral: swift.Identifier
    var Id_dictionaryLiteral: swift.Identifier
    var Id_className: swift.Identifier
    var Id__defaultActorInitialize: swift.Identifier
    var Id__defaultActorDestroy: swift.Identifier
    var Id__defaultActorEnqueue: swift.Identifier
    var Id_ErrorType: swift.Identifier
    var Id_Code: swift.Identifier
    var Id_nsError: swift.Identifier
    var Id_OSLogMessage: swift.Identifier
    var Id_OSLog: swift.Identifier
    var Id_OSLogType: swift.Identifier
    var Id_AtomicLoadOrdering: swift.Identifier
    var Id_AtomicStoreOrdering: swift.Identifier
    var Id_AtomicUpdateOrdering: swift.Identifier
    var Id_along: swift.Identifier
    var Id_differential: swift.Identifier
    var Id_direction: swift.Identifier
    var Id_move: swift.Identifier
    var Id_pullback: swift.Identifier
    var Id_TangentVector: swift.Identifier
    var Id_zero: swift.Identifier
    var Id_zeroTangentVectorInitializer: swift.Identifier

    /// Cache for names of canonical GenericTypeParamTypes.
    var CanonicalGenericTypeParamTypeNames: llvm.__CxxTemplateInstN4llvm8DenseMapIjN5swift10IdentifierENS_12DenseMapInfoIjEENS_6detail12DenseMapPairIjS2_EEEE

    /// Cache of remapped types (useful for diagnostics).
    var RemappedTypes: llvm.__CxxTemplateInstN4llvm9StringMapIN5swift4TypeENS_15MallocAllocatorEEE

    /// The # of times we have performed typo correction.
    var NumTypoCorrections: UInt32

    /// The next auto-closure discriminator.  This needs to be preserved
    /// across invocations of both the parser and the type-checker.
    var NextAutoClosureDiscriminator: UInt32

    /// Cached mapping from types to their associated tangent spaces.
    var AutoDiffTangentSpaces: llvm.__CxxTemplateInstN4llvm8DenseMapIN5swift4TypeENS_8OptionalINS1_12TangentSpaceEEENS_12DenseMapInfoIS2_EENS_6detail12DenseMapPairIS2_S5_EEEE

    /// A cache of derivative function types per configuration.
    var SILAutoDiffDerivativeFunctions: llvm.__CxxTemplateInstN4llvm8DenseMapIN5swift32SILAutoDiffDerivativeFunctionKeyENS1_14CanTypeWrapperINS1_15SILFunctionTypeEEENS_12DenseMapInfoIS2_EENS_6detail12DenseMapPairIS2_S5_EEEE

    /// Cache of `@differentiable` attributes keyed by parameter indices. Used to
    /// diagnose duplicate `@differentiable` attributes for the same key.
    var DifferentiableAttrs: llvm.__CxxTemplateInstN4llvm8DenseMapINSt3__14pairIPN5swift4DeclEPNS3_11IndexSubsetEEEPNS3_18DifferentiableAttrENS_12DenseMapInfoIS8_EENS_6detail12DenseMapPairIS8_SA_EEEE

    /// Cache of `@derivative` attributes keyed by parameter indices and
    /// derivative function kind. Used to diagnose duplicate `@derivative`
    /// attributes for the same key.
    var DerivativeAttrs: llvm.__CxxTemplateInstN4llvm8DenseMapINSt3__15tupleIJPN5swift4DeclEPNS3_11IndexSubsetENS3_30AutoDiffDerivativeFunctionKindEEEENS_11SmallPtrSetIPNS3_14DerivativeAttrELj1EEENS_12DenseMapInfoIS9_EENS_6detail12DenseMapPairIS9_SD_EEEE
    var TheErrorType: swift.CanType { get }

    /// This is the ErrorType singleton.
    var TheUnresolvedType: swift.CanType { get }

    /// This is the UnresolvedType singleton.
    var TheEmptyTupleType: swift.CanType { get }

    /// This is '()', aka Void
    var TheAnyType: swift.CanType { get }
    var TheIntegerLiteralType: swift.CanType { get }
    var TheJobType: swift.CanType { get }
    var TheRawPointerType: swift.CanType { get }
    var TheRawUnsafeContinuationType: swift.CanType { get }
    var TheNativeObjectType: swift.CanType { get }
    var TheBridgeObjectType: swift.CanType { get }
    var TheUnsafeValueBufferType: swift.CanType { get }
    var TheDefaultActorStorageType: swift.CanType { get }
    var TheSILTokenType: swift.CanType { get }
    var TheIEEE32Type: swift.CanType { get }

    /// 32-bit IEEE floating point
    var TheIEEE64Type: swift.CanType { get }

    /// 64-bit IEEE floating point
    var TheIEEE16Type: swift.CanType { get }

    /// 16-bit IEEE floating point
    var TheIEEE80Type: swift.CanType { get }

    /// 80-bit IEEE floating point
    var TheIEEE128Type: swift.CanType { get }

    /// 128-bit IEEE floating point
    var ThePPC128Type: swift.CanType { get }
    static func get(_ langOpts: UnsafeMutablePointer<swift.LangOptions>, _ typeckOpts: UnsafeMutablePointer<swift.TypeCheckerOptions>, _ SearchPathOpts: UnsafeMutablePointer<swift.SearchPathOptions>, _ ClangImporterOpts: UnsafeMutablePointer<swift.ClangImporterOptions>, _ SourceMgr: UnsafeMutablePointer<swift.SourceManager>, _ Diags: UnsafeMutablePointer<swift.DiagnosticEngine>) -> UnsafeMutablePointer<swift.ASTContext>!

    /// Allocate - Allocate memory from the ASTContext bump pointer.
    mutating func Allocate(_ bytes: UInt, _ alignment: UInt32, _ arena: swift.AllocationArena) -> UnsafeMutableRawPointer!
    mutating func Allocate<T>(_ arena: swift.AllocationArena) -> OpaquePointer!

    /// Allocate a copy of the specified object.
    mutating func AllocateObjectCopy<T>(_ t: UnsafeMutablePointer<T>, _ arena: swift.AllocationArena) -> OpaquePointer!
    mutating func AllocateCopy<T, It>(_ start: It, _ end: It, _ arena: swift.AllocationArena) -> OpaquePointer!
    mutating func AllocateCopy(_ Str: llvm.StringRef, _ arena: swift.AllocationArena) -> llvm.StringRef

    /// Set a new stats reporter.
    mutating func setStatsReporter(_ stats: UnsafeMutablePointer<swift.UnifiedStatsReporter>!)

    /// getIdentifier - Return the uniqued and AST-Context-owned version of the
    /// specified string.
    mutating func getIdentifier(_ Str: llvm.StringRef) -> swift.Identifier

    /// Decide how to interpret two precedence groups.
    mutating func associateInfixOperators(_ left: UnsafeMutablePointer<swift.PrecedenceGroupDecl>!, _ right: UnsafeMutablePointer<swift.PrecedenceGroupDecl>!) -> swift.Associativity

    /// Retrieve the declaration of Swift.Error.
    mutating func getErrorDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getExceptionType() -> swift.CanType
    mutating func getVoidDecl() -> UnsafeMutablePointer<swift.TypeAliasDecl>!
    mutating func getBoolDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getIntDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getInt64Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getInt32Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getInt16Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getInt8Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUIntDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUInt64Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUInt32Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUInt16Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUInt8Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getFloatDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getDoubleDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getFloat80Decl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func get_MaxBuiltinFloatTypeDecl() -> UnsafeMutablePointer<swift.TypeAliasDecl>!
    mutating func getStringDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getStaticStringDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getSubstringDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getArrayDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getSetDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getSequenceDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getDictionaryDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getCollectionDifferenceDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getAnyHashableDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getMutableCollectionDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getHasherDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getAnyKeyPathDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getPartialKeyPathDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getKeyPathDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getWritableKeyPathDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getReferenceWritableKeyPathDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getOptionalDecl() -> UnsafeMutablePointer<swift.EnumDecl>!
    mutating func getOptionSetDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeMutableRawPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeRawPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeMutablePointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafePointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getOpaquePointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getAutoreleasingUnsafeMutablePointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeBufferPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeMutableBufferPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeRawBufferPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeMutableRawBufferPointerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnmanagedDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getNeverDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getEncoderDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getDecoderDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getKeyedEncodingContainerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getKeyedDecodingContainerDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getRangeReplaceableCollectionDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!

    /// Retrieve the declaration of Swift.Optional<T>.Some.
    mutating func getOptionalSomeDecl() -> UnsafeMutablePointer<swift.EnumElementDecl>!

    /// Retrieve the declaration of Swift.Optional<T>.None.
    mutating func getOptionalNoneDecl() -> UnsafeMutablePointer<swift.EnumElementDecl>!

    /// Retrieve the declaration of the "pointee" property of a pointer type.
    mutating func getPointerPointeePropertyDecl(_ ptrKind: swift.PointerTypeKind) -> UnsafeMutablePointer<swift.VarDecl>!

    /// Retrieve the type Swift.AnyObject.
    mutating func getAnyObjectType() -> swift.CanType

    /// Retrieve the type Swift.Never.
    mutating func getNeverType() -> swift.CanType
    mutating func getNSCopyingDecl() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getNSCopyingType() -> swift.`Type`
    mutating func getNSErrorDecl() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func getNSErrorType() -> swift.`Type`
    mutating func getNSNumberDecl() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func getNSNumberType() -> swift.`Type`
    mutating func getNSValueDecl() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func getNSValueType() -> swift.`Type`
    mutating func getNSObjectDecl() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func getNSObjectType() -> swift.`Type`
    mutating func getSelectorDecl() -> UnsafeMutablePointer<swift.StructDecl>!
    mutating func getSelectorType() -> swift.`Type`
    mutating func getObjCBoolDecl() -> UnsafeMutablePointer<swift.StructDecl>!
    mutating func getObjCBoolType() -> swift.`Type`
    mutating func getUnsafeContinuationDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeContinuationType() -> swift.`Type`
    mutating func getUnsafeThrowingContinuationDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    mutating func getUnsafeThrowingContinuationType() -> swift.`Type`
    mutating func getArrayForceCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getArrayConditionalCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDictionaryUpCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDictionaryDownCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDictionaryDownCastConditional() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSetUpCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSetDownCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSetDownCastConditional() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertPointerToPointerArgument() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertInOutToPointerArgument() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertMutableArrayToPointerArgument() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertConstArrayToPointerArgument() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertConstStringToUTF8PointerArgument() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getAllocateUninitializedArray() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDeallocateUninitializedArray() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getFinalizeUninitializedArray() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getForceBridgeFromObjectiveC() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConditionallyBridgeFromObjectiveC() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getForceBridgeFromObjectiveCBridgeable() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConditionallyBridgeFromObjectiveCBridgeable() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getBridgeAnythingToObjectiveC() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getBridgeAnyObjectToAny() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getConvertToAnyHashable() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDiagnoseUnexpectedError() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDiagnoseUnexpectedNilOptional() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDiagnoseUnexpectedEnumCase() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getDiagnoseUnexpectedEnumCaseValue() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getGetErrorEmbeddedNSError() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getUnsafeBitCast() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getGetAtKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getGetAtAnyKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getGetAtPartialKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSetAtWritableKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSetAtReferenceWritableKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getReadAtKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getModifyAtWritableKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getModifyAtReferenceWritableKeyPath() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getSwap() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getUnimplementedInitializer() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getUndefined() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Get the '+' function on two RangeReplaceableCollection.
    mutating func getPlusFunctionOnRangeReplaceableCollection() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Get the '+' function on two String.
    mutating func getPlusFunctionOnString() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Get Sequence.makeIterator().
    mutating func getSequenceMakeIterator() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Check whether the standard library provides all the correct
    /// intrinsic support for Optional<T>.
    ///
    /// If this is true, the four methods above all promise to return
    /// non-null.
    mutating func hasOptionalIntrinsics() -> Bool

    /// Check whether the standard library provides all the correct
    /// intrinsic support for UnsafeMutablePointer<T> function arguments.
    ///
    /// If this is true, the methods getConvert*ToPointerArgument
    /// all promise to return non-null.
    mutating func hasPointerArgumentIntrinsics() -> Bool

    /// Check whether the standard library provides all the correct
    /// intrinsic support for array literals.
    ///
    /// If this is true, the method getAllocateUninitializedArray
    /// promises to return non-null.
    mutating func hasArrayLiteralIntrinsics() -> Bool

    /// Retrieve the declaration of Swift.Bool.init(_builtinBooleanLiteral:)
    mutating func getBoolBuiltinInitDecl() -> swift.ConcreteDeclRef

    /// Retrieve the witness for init(_builtinIntegerLiteral:).
    mutating func getIntBuiltinInitDecl(_ intDecl: UnsafeMutablePointer<swift.NominalTypeDecl>!) -> swift.ConcreteDeclRef

    /// Retrieve the witness for init(_builtinFloatLiteral:).
    mutating func getFloatBuiltinInitDecl(_ floatDecl: UnsafeMutablePointer<swift.NominalTypeDecl>!) -> swift.ConcreteDeclRef

    /// Retrieve the witness for (_builtinStringLiteral:utf8CodeUnitCount:isASCII:).
    mutating func getStringBuiltinInitDecl(_ stringDecl: UnsafeMutablePointer<swift.NominalTypeDecl>!) -> swift.ConcreteDeclRef

    /// Retrieve the declaration of Swift.<(Int, Int) -> Bool.
    mutating func getLessThanIntDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Retrieve the declaration of Swift.==(Int, Int) -> Bool.
    mutating func getEqualIntDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Retrieve the declaration of Swift._hashValue<H>(for: H) -> Int.
    mutating func getHashValueForDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Retrieve the declaration of Array.append(element:)
    mutating func getArrayAppendElementDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Retrieve the declaration of
    /// Array.reserveCapacityForAppend(newElementsCount: Int)
    mutating func getArrayReserveCapacityDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Retrieve the declaration of String.init(_builtinStringLiteral ...)
    mutating func getMakeUTF8StringDecl() -> UnsafeMutablePointer<swift.ConstructorDecl>!
    mutating func getIsOSVersionAtLeastDecl() -> UnsafeMutablePointer<swift.FuncDecl>!

    /// Look for the declaration with the given name within the
    /// Swift module.
    mutating func lookupInSwiftModule(_ name: llvm.StringRef, _ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)

    /// Retrieve a specific, known protocol.
    mutating func getProtocol(_ kind: swift.KnownProtocolKind) -> UnsafeMutablePointer<swift.ProtocolDecl>!

    /// Determine whether the given nominal type is one of the standard
    /// library or Cocoa framework types that is known to be bridged by another
    /// module's overlay, for layering or implementation detail reasons.
    mutating func isTypeBridgedInExternalModule(_ nominal: UnsafeMutablePointer<swift.NominalTypeDecl>!) -> Bool

    /// True if the given type is an Objective-C class that serves as the bridged
    /// object type for many Swift value types, meaning that the conversion from
    /// an object to a value is a conditional cast.
    mutating func isObjCClassWithMultipleSwiftBridgedTypes(_ t: swift.`Type`) -> Bool

    /// Get the Objective-C type that a Swift type bridges to, if any.
    /// 
    /// \param dc The context in which bridging is occurring.
    /// \param type The Swift for which we are querying bridging behavior.
    /// \param bridgedValueType The specific value type that is bridged,
    /// which will usually by the same as \c type.
    mutating func getBridgedToObjC(_ dc: UnsafePointer<swift.DeclContext>!, _ type: swift.`Type`, _ bridgedValueType: UnsafeMutablePointer<swift.`Type`>!) -> swift.`Type`

    /// Get the Clang type corresponding to a Swift function type.
    ///
    /// \param params The function parameters.
    /// \param resultTy The Swift result type.
    /// \param trueRep The actual calling convention, which must be C-compatible.
    mutating func getClangFunctionType(_ params: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15AnyFunctionType5ParamEEE, _ resultTy: swift.`Type`, _ trueRep: swift.FunctionTypeRepresentation) -> UnsafePointer<clang.`Type`>!

    /// Get the canonical Clang type corresponding to a SIL function type.
    ///
    /// SIL analog of \c ASTContext::getClangFunctionType .
    mutating func getCanonicalClangFunctionType(_ params: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift16SILParameterInfoEEE, _ result: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13SILResultInfoEEE, _ trueRep: swift.SILFunctionType.Representation) -> UnsafePointer<clang.`Type`>!

    /// Get the Swift declaration that a Clang declaration was exported from,
    /// if applicable.
    mutating func getSwiftDeclForExportedClangDecl(_ decl: UnsafePointer<clang.Decl>!) -> UnsafePointer<swift.Decl>!

    /// General conversion method from Swift types -> Clang types.
    ///
    /// HACK: This method is only intended to be called from a specific place in
    /// IRGen. For converting function types, strongly prefer using one of the
    /// other methods instead, instead of manually iterating over parameters
    /// and results.
    mutating func getClangTypeForIRGen(_ ty: swift.`Type`) -> UnsafePointer<clang.`Type`>!

    /// Add a cleanup function to be called when the ASTContext is deallocated.
    mutating func addCleanup(_ cleanup: std.__1.__CxxTemplateInstNSt3__18functionIFvvEEE)

    /// Add a cleanup to run the given object's destructor when the ASTContext is
    /// deallocated.
    mutating func addDestructorCleanup<T>(_ object: UnsafeMutablePointer<T>)

    /// Get the runtime availability of the class metadata update callback
    /// mechanism for the target platform.
    mutating func getObjCMetadataUpdateCallbackAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of the objc_getClass() hook for the target
    /// platform.
    mutating func getObjCGetClassHookAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of features introduced in the Swift 5.0
    /// compiler for the target platform.
    mutating func getSwift50Availability() -> swift.AvailabilityContext

    /// Get the runtime availability of the opaque types language feature for the
    /// target platform.
    mutating func getOpaqueTypeAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of the objc_loadClassref() entry point for
    /// the target platform.
    mutating func getObjCClassStubsAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of features introduced in the Swift 5.1
    /// compiler for the target platform.
    mutating func getSwift51Availability() -> swift.AvailabilityContext

    /// Get the runtime availability of
    /// swift_getTypeByMangledNameInContextInMetadataState.
    mutating func getTypesInAbstractMetadataStateAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of support for prespecialized generic 
    /// metadata.
    mutating func getPrespecializedGenericMetadataAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of the swift_compareTypeContextDescriptors
    /// for the target platform.
    mutating func getCompareTypeContextDescriptorsAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of the
    /// swift_compareProtocolConformanceDescriptors entry point for the target
    /// platform.
    mutating func getCompareProtocolConformanceDescriptorsAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of support for inter-module prespecialized
    /// generic metadata.
    mutating func getIntermodulePrespecializedGenericMetadataAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of support for concurrency.
    mutating func getConcurrencyAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of support for differentiation.
    mutating func getDifferentiationAvailability() -> swift.AvailabilityContext

    /// Get the runtime availability of features introduced in the Swift 5.2
    /// compiler for the target platform.
    mutating func getSwift52Availability() -> swift.AvailabilityContext

    /// Get the runtime availability of features introduced in the Swift 5.3
    /// compiler for the target platform.
    mutating func getSwift53Availability() -> swift.AvailabilityContext

    /// Get the runtime availability of features introduced in the Swift 5.4
    /// compiler for the target platform.
    mutating func getSwift54Availability() -> swift.AvailabilityContext

    /// Get the runtime availability of features that have been introduced in the
    /// Swift compiler for future versions of the target platform.
    mutating func getSwiftFutureAvailability() -> swift.AvailabilityContext
    mutating func hadError() -> Bool

    /// Adds a search path to SearchPathOpts, unless it is already present.
    ///
    /// Does any proper bookkeeping to keep all module loaders up to date as well.
    mutating func addSearchPath(_ searchPath: llvm.StringRef, _ isFramework: Bool, _ isSystem: Bool)

    /// Retrieve the module interface checker associated with this AST context.
    mutating func getModuleInterfaceChecker() -> UnsafeMutablePointer<swift.ModuleInterfaceChecker>!

    /// Load extensions to the given nominal type from the external
    /// module loaders.
    ///
    /// \param nominal The nominal type whose extensions should be loaded.
    ///
    /// \param previousGeneration The previous generation number. The AST already
    /// contains extensions loaded from any generation up to and including this
    /// one.
    mutating func loadExtensions(_ nominal: UnsafeMutablePointer<swift.NominalTypeDecl>!, _ previousGeneration: UInt32)

    /// Retrieve the Clang module loader for this ASTContext.
    ///
    /// If there is no Clang module loader, returns a null pointer.
    /// The loader is owned by the AST context.
    mutating func getClangModuleLoader() -> UnsafeMutablePointer<swift.ClangModuleLoader>!

    /// Retrieve the DWARF module loader for this ASTContext.
    ///
    /// If there is no Clang module loader, returns a null pointer.
    /// The loader is owned by the AST context.
    mutating func getDWARFModuleLoader() -> UnsafeMutablePointer<swift.ClangModuleLoader>!

    /// Returns an iterator over the modules that are known by this context
    /// to be loaded.
    ///
    /// Iteration order is guaranteed to match the order in which
    /// \c addLoadedModule was called to register the loaded module
    /// with this context.
    mutating func getLoadedModules() -> llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__111__wrap_iterIPKNS1_4pairIN5swift10IdentifierEPNS4_10ModuleDeclEEEEEEE

    /// Returns the number of loaded modules known by this context to be loaded.
    mutating func getNumLoadedModules() -> UInt32

    /// Asks every module loader to verify the ASTs it has loaded.
    ///
    /// Does nothing in non-asserts (NDEBUG) builds.
    mutating func verifyAllLoadedModules()

    /// Check whether the module with a given name can be imported without
    /// importing it.
    ///
    /// Note that even if this check succeeds, errors may still occur if the
    /// module is loaded in full.
    mutating func canImportModule(_ ModulePath: swift.ImportPath.Element) -> Bool

    /// \returns a module with a given name that was already loaded.  If the
    /// module was not loaded, returns nullptr.
    mutating func getLoadedModule(_ ModulePath: swift.ImportPath.Module) -> UnsafeMutablePointer<swift.ModuleDecl>!
    mutating func getLoadedModule(_ ModuleName: swift.Identifier) -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Attempts to load a module into this ASTContext.
    ///
    /// If a module by this name has already been loaded, the existing module will
    /// be returned.
    ///
    /// \returns The requested module, or NULL if the module cannot be found.
    mutating func getModule(_ ModulePath: swift.ImportPath.Module) -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Attempts to load the matching overlay module for the given clang
    /// module into this ASTContext.
    ///
    /// \returns The Swift overlay module corresponding to the given Clang module,
    /// or NULL if the overlay module cannot be found.
    mutating func getOverlayModule(_ ClangModule: UnsafePointer<swift.FileUnit>!) -> UnsafeMutablePointer<swift.ModuleDecl>!
    mutating func getModuleByName(_ ModuleName: llvm.StringRef) -> UnsafeMutablePointer<swift.ModuleDecl>!
    mutating func getModuleByIdentifier(_ ModuleID: swift.Identifier) -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Returns the standard library module, or null if the library isn't present.
    ///
    /// If \p loadIfAbsent is true, the ASTContext will attempt to load the module
    /// if it hasn't been set yet.
    mutating func getStdlibModule(_ loadIfAbsent: Bool) -> UnsafeMutablePointer<swift.ModuleDecl>!
    mutating func getStdlibModule() -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Insert an externally-sourced module into the set of known loaded modules
    /// in this context.
    mutating func addLoadedModule(_ M: UnsafeMutablePointer<swift.ModuleDecl>!)

    /// Retrieve the current generation number, which reflects the
    /// number of times a module import has caused mass invalidation of
    /// lookup tables.
    ///
    /// Various places in the AST keep track of the generation numbers at which
    /// their own information is valid, such as the list of extensions associated
    /// with a nominal type.
    mutating func getCurrentGeneration() -> UInt32

    /// Increase the generation number, implying that various lookup
    /// tables have been significantly altered by the introduction of a new
    /// module import.
    ///
    /// \returns the previous generation number.
    mutating func bumpGeneration() -> UInt32

    /// Produce a self-conformance for the given protocol.
    mutating func getSelfConformance(_ protocol: UnsafeMutablePointer<swift.ProtocolDecl>!) -> OpaquePointer!

    /// Check whether current context has any errors associated with
    /// ill-formed protocol conformances which haven't been produced yet.
    mutating func hasDelayedConformanceErrors() -> Bool

    /// Add a delayed diagnostic produced while type-checking a
    /// particular protocol conformance.
    mutating func addDelayedConformanceDiag(_ conformance: OpaquePointer!, _ fn: swift.ASTContext.DelayedConformanceDiag)

    /// Produce a specialized conformance, which takes a generic
    /// conformance and substitutions written in terms of the generic
    /// conformance's signature.
    ///
    /// \param type The type for which we are retrieving the conformance.
    ///
    /// \param generic The generic conformance.
    ///
    /// \param substitutions The set of substitutions required to produce the
    /// specialized conformance from the generic conformance.
    mutating func getSpecializedConformance(_ type: swift.`Type`, _ generic: OpaquePointer!, _ substitutions: swift.SubstitutionMap) -> OpaquePointer!

    /// Produce an inherited conformance, for subclasses of a type
    /// that already conforms to a protocol.
    ///
    /// \param type The type for which we are retrieving the conformance.
    ///
    /// \param inherited The inherited conformance.
    mutating func getInheritedConformance(_ type: swift.`Type`, _ inherited: OpaquePointer!) -> OpaquePointer!

    /// Get the lazy data for the given declaration.
    ///
    /// \param lazyLoader If non-null, the lazy loader to use when creating the
    /// lazy data. The pointer must either be null or be consistent
    /// across all calls for the same \p func.
    mutating func getOrCreateLazyContextData(_ decl: UnsafePointer<swift.DeclContext>!, _ lazyLoader: OpaquePointer!) -> OpaquePointer!

    /// Get the lazy iterable context for the given iterable declaration context.
    ///
    /// \param lazyLoader If non-null, the lazy loader to use when creating the
    /// iterable context data. The pointer must either be null or be consistent
    /// across all calls for the same \p idc.
    mutating func getOrCreateLazyIterableContextData(_ idc: UnsafePointer<swift.IterableDeclContext>!, _ lazyLoader: OpaquePointer!) -> OpaquePointer!

    /// Access the side cache for property wrapper backing property types,
    /// used because TypeChecker::typeCheckBinding() needs somewhere to stash
    /// the backing property type.
    mutating func getSideCachedPropertyWrapperBackingPropertyType(_ var: UnsafeMutablePointer<swift.VarDecl>!) -> swift.`Type`
    mutating func setSideCachedPropertyWrapperBackingPropertyType(_ var: UnsafeMutablePointer<swift.VarDecl>!, _ type: swift.`Type`)

    /// Returns memory usage of this ASTContext.
    mutating func getTotalMemory() -> Int

    /// Returns memory used exclusively by constraint solver.
    mutating func getSolverMemory() -> Int

    /// Retrieve the Swift name for the given Foundation entity, where
    /// "NS" prefix stripping will apply under omit-needless-words.
    mutating func getSwiftName(_ kind: swift.KnownFoundationEntity) -> llvm.StringRef

    /// Retrieve the Swift identifier for the given Foundation entity, where
    /// "NS" prefix stripping will apply under omit-needless-words.
    mutating func getSwiftId(_ kind: swift.KnownFoundationEntity) -> swift.Identifier

    /// Whether to perform typo correction given the pre-configured correction limit.
    /// Increments \c NumTypoCorrections then checks this against the limit in
    /// the language options.
    mutating func shouldPerformTypoCorrection() -> Bool

    /// Retrieve or create the stored generic signature builder for the given
    /// canonical generic signature and module.
    mutating func getOrCreateGenericSignatureBuilder(_ sig: swift.CanGenericSignature) -> OpaquePointer!

    /// Retrieve a generic signature with a single unconstrained type parameter,
    /// like `<T>`.
    mutating func getSingleGenericParameterSignature() -> swift.CanGenericSignature

    /// Retrieve a generic signature with a single type parameter conforming
    /// to the given protocol or composition type, like <T: type>.
    mutating func getOpenedArchetypeSignature(_ type: swift.`Type`) -> swift.CanGenericSignature
    mutating func getOverrideGenericSignature(_ base: UnsafePointer<swift.ValueDecl>!, _ derived: UnsafePointer<swift.ValueDecl>!) -> swift.GenericSignature
    mutating func overrideGenericSignatureReqsSatisfied(_ base: UnsafePointer<swift.ValueDecl>!, _ derived: UnsafePointer<swift.ValueDecl>!, _ direction: swift.ASTContext.OverrideGenericSignatureReqCheck) -> Bool

    /// Whether our effective Swift version is at least 'major'.
    ///
    /// This is usually the check you want; for example, when introducing
    /// a new language feature which is only visible in Swift 5, you would
    /// check for isSwiftVersionAtLeast(5).
    mutating func isSwiftVersionAtLeast(_ major: UInt32, _ minor: UInt32) -> Bool

    /// Check whether it's important to respect access control restrictions
    /// in current context.
    mutating func isAccessControlDisabled() -> Bool

    /// Each kind and SourceFile has its own cache for a Type.
    mutating func getDefaultTypeRequestCache(_: UnsafeMutablePointer<swift.SourceFile>!, _: swift.KnownProtocolKind) -> UnsafeMutablePointer<swift.`Type`>

    /// Check whether a given string would be considered "pure ASCII" by the
    /// standard library's String implementation.
    mutating func isASCIIString(_ s: llvm.StringRef) -> Bool
  }
  struct FileUnit {
    mutating func getKind() -> swift.FileUnitKind

    /// Look up a (possibly overloaded) value set at top-level scope
    /// (but with the specified access path, which may come from an import decl)
    /// within this file.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupValue(_ name: swift.DeclName, _ lookupKind: swift.NLKind, _ result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)

    /// Look up a local type declaration by its mangled name.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupLocalType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.TypeDecl>!

    /// Look up an opaque return type by the mangled name of the declaration
    /// that defines it.
    mutating func lookupOpaqueResultType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.OpaqueTypeDecl>!

    /// Directly look for a nested type declared within this module inside the
    /// given nominal type (including any extensions).
    ///
    /// This is a fast-path hack to avoid circular dependencies in deserialization
    /// and the Clang importer.
    ///
    /// Private and fileprivate types should not be returned by this lookup.
    mutating func lookupNestedType(_ name: swift.Identifier, _ parent: UnsafePointer<swift.NominalTypeDecl>!) -> UnsafeMutablePointer<swift.TypeDecl>!

    /// Finds class members defined in this file with the given name.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupClassMember(_ accessPath: swift.ImportPath.Access, _ name: swift.DeclName, _ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)
    mutating func loadFingerprint(_ IDC: UnsafePointer<swift.IterableDeclContext>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11FingerprintEEE

    /// Returns the comment attached to the given declaration.
    ///
    /// This function is an implementation detail for comment serialization.
    /// If you just want to get a comment attached to a decl, use
    /// \c Decl::getRawComment() or \c Decl::getBriefComment().
    mutating func getCommentForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11CommentInfoEEE
    mutating func getGroupNameForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalINS_9StringRefEEE
    mutating func getSourceFileNameForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalINS_9StringRefEEE
    mutating func getSourceOrderForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE
    mutating func getGroupNameByUSR(_ USR: llvm.StringRef) -> llvm.__CxxTemplateInstN4llvm8OptionalINS_9StringRefEEE
    mutating func getBasicLocsForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13BasicDeclLocsEEE
    mutating func collectAllGroups(_ Names: UnsafeMutablePointer<std.__1.__CxxTemplateInstNSt3__16vectorIN4llvm9StringRefENS_9allocatorIS2_EEEE>)

    /// Returns an implementation-defined "discriminator" for \p D, which
    /// distinguishes \p D from other declarations in the same module with the
    /// same name.
    ///
    /// Since this value is used in name mangling, it should be a valid ASCII-only
    /// identifier.
    mutating func getDiscriminatorForPrivateValue(_ D: UnsafePointer<swift.ValueDecl>!) -> swift.Identifier

    /// Finds all top-level decls in this file.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    /// The order of the results is not guaranteed to be meaningful.
    mutating func getTopLevelDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)
    mutating func getExportedPrespecializations(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)
    mutating func getOpaqueReturnTypeDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14OpaqueTypeDeclEEE>)

    /// Adds all top-level decls to the given vector.
    ///
    /// This includes all decls that should be displayed to clients of the module.
    /// The order of the results is not guaranteed to be meaningful.
    ///
    /// This can differ from \c getTopLevelDecls, e.g. it returns decls from a
    /// shadowed clang module.
    mutating func getDisplayDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)

    /// Generates the list of libraries needed to link this file, based on its
    /// imports.
    mutating func collectLinkLibraries(_ callback: swift.ModuleDecl.LinkLibraryCallback)

    /// Returns the path of the file or directory that defines the module
    /// represented by this \c FileUnit, or empty string if there is none.
    /// Cross-import overlay specifiers are found relative to this path.
    mutating func getModuleDefiningPath() -> llvm.StringRef

    /// True if this file contains the main class for the module.
    mutating func hasMainClass() -> Bool
    mutating func getMainClass() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func hasMainDecl() -> Bool
    mutating func getMainDecl() -> UnsafeMutablePointer<swift.Decl>!
    mutating func getMainFunc() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func hasEntryPoint() -> Bool
    mutating func getUnderlyingModuleIfOverlay() -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Returns the associated clang module if one exists.
    mutating func getUnderlyingClangModule() -> UnsafePointer<clang.Module>!

    /// Returns the name to use when referencing entities in this file.
    ///
    /// Usually this is the module name itself, but certain Clang features allow
    /// substituting another name instead.
    mutating func getExportedModuleName() -> llvm.StringRef
    mutating func getParentModule() -> UnsafeMutablePointer<swift.ModuleDecl>!
    static func classof(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool
  }

  /// FuncDecl - 'func' declaration.
  struct FuncDecl {

    /// Factory function only for use by deserialization.
    static func createDeserialized(_ Context: UnsafeMutablePointer<swift.ASTContext>, _ StaticSpelling: swift.StaticSpellingKind, _ Name: swift.DeclName, _ Async: Bool, _ Throws: Bool, _ GenericParams: OpaquePointer!, _ FnRetType: swift.`Type`, _ Parent: UnsafeMutablePointer<swift.DeclContext>!) -> UnsafeMutablePointer<swift.FuncDecl>!
    static func create(_ Context: UnsafeMutablePointer<swift.ASTContext>, _ StaticLoc: swift.SourceLoc, _ StaticSpelling: swift.StaticSpellingKind, _ FuncLoc: swift.SourceLoc, _ Name: swift.DeclName, _ NameLoc: swift.SourceLoc, _ Async: Bool, _ AsyncLoc: swift.SourceLoc, _ Throws: Bool, _ ThrowsLoc: swift.SourceLoc, _ GenericParams: OpaquePointer!, _ BodyParams: OpaquePointer!, _ ResultTyR: OpaquePointer!, _ Parent: UnsafeMutablePointer<swift.DeclContext>!) -> UnsafeMutablePointer<swift.FuncDecl>!
    static func createImplicit(_ Context: UnsafeMutablePointer<swift.ASTContext>, _ StaticSpelling: swift.StaticSpellingKind, _ Name: swift.DeclName, _ NameLoc: swift.SourceLoc, _ Async: Bool, _ Throws: Bool, _ GenericParams: OpaquePointer!, _ BodyParams: OpaquePointer!, _ FnRetType: swift.`Type`, _ Parent: UnsafeMutablePointer<swift.DeclContext>!) -> UnsafeMutablePointer<swift.FuncDecl>!
    static func createImported(_ Context: UnsafeMutablePointer<swift.ASTContext>, _ FuncLoc: swift.SourceLoc, _ Name: swift.DeclName, _ NameLoc: swift.SourceLoc, _ Async: Bool, _ Throws: Bool, _ BodyParams: OpaquePointer!, _ FnRetType: swift.`Type`, _ GenericParams: OpaquePointer!, _ Parent: UnsafeMutablePointer<swift.DeclContext>!, _ ClangN: swift.ClangNode) -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func isStatic() -> Bool

    /// \returns the way 'static'/'class' was spelled in the source.
    mutating func getStaticSpelling() -> swift.StaticSpellingKind

    /// \returns the way 'static'/'class' should be spelled for this declaration.
    mutating func getCorrectStaticSpelling() -> swift.StaticSpellingKind
    mutating func setStatic(_ IsStatic: Bool)
    mutating func isMutating() -> Bool
    mutating func isNonMutating() -> Bool
    mutating func isConsuming() -> Bool
    mutating func isCallAsFunctionMethod() -> Bool
    mutating func isMainTypeMainMethod() -> Bool

    /// Whether the given name is enqueue(partialTask:), which is used for
    /// actors.
    static func isEnqueuePartialTaskName(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ name: swift.DeclName) -> Bool

    /// Determine whether this function is the witness to the Actor protocol's
    /// enqueue(partialTask:) operation within an actor.
    mutating func isActorEnqueuePartialTaskWitness() -> Bool
    mutating func getSelfAccessKind() -> swift.SelfAccessKind
    mutating func setSelfAccessKind(_ mod: swift.SelfAccessKind)
    mutating func getStaticLoc() -> swift.SourceLoc
    mutating func getFuncLoc() -> swift.SourceLoc
    mutating func getStartLoc() -> swift.SourceLoc
    mutating func getSourceRange() -> swift.SourceRange
    mutating func getResultTypeRepr() -> OpaquePointer!
    mutating func getResultTypeSourceRange() -> swift.SourceRange

    /// Retrieve the result interface type of this function.
    mutating func getResultInterfaceType() -> swift.`Type`

    /// isUnaryOperator - Determine whether this is a unary operator
    /// implementation.  This check is a syntactic rather than type-based check,
    /// which looks at the number of parameters specified, in order to allow
    /// for the definition of unary operators on tuples, as in:
    ///
    ///   prefix func + (param : (a:Int, b:Int))
    ///
    /// This also allows the unary-operator-ness of a func decl to be determined
    /// prior to type checking.
    mutating func isUnaryOperator() -> Bool

    /// isBinaryOperator - Determine whether this is a binary operator
    /// implementation.  This check is a syntactic rather than type-based check,
    /// which looks at the number of parameters specified, in order to allow
    /// distinguishing a binary operator from a unary operator on tuples, as in:
    ///
    ///   prefix func + (_:(a:Int, b:Int)) // unary operator +(1,2)
    ///   infix func  + (a:Int, b:Int)     // binary operator 1 + 2
    ///
    /// This also allows the binary-operator-ness of a func decl to be determined
    /// prior to type checking.
    mutating func isBinaryOperator() -> Bool
    mutating func getLocalCaptures(_ Result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift13CapturedValueEEE>)
    mutating func getImplicitSelfDeclStorage() -> UnsafeMutablePointer<UnsafeMutablePointer<swift.ParamDecl>?>!

    /// Get the supertype method this method overrides, if any.
    mutating func getOverriddenDecl() -> UnsafeMutablePointer<swift.FuncDecl>!
    mutating func getOperatorDecl() -> UnsafeMutablePointer<swift.OperatorDecl>!

    /// Returns true if the function is forced to be statically dispatched.
    mutating func hasForcedStaticDispatch() -> Bool
    mutating func setForcedStaticDispatch(_ flag: Bool)
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.AbstractFunctionDecl>!) -> Bool
    static func classof(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool

    /// True if the function is a defer body.
    mutating func isDeferBody() -> Bool

    /// Perform basic checking to determine whether the @IBAction or
    /// @IBSegueAction attribute can be applied to this function.
    mutating func isPotentialIBActionTarget() -> Bool
    mutating func hasTopLevelLocalContextCaptures() -> Bool
    mutating func setHasTopLevelLocalContextCaptures(_ hasCaptures: Bool)
  }

  /// An abstract description of a key path pattern.
  struct KeyPathPattern {
    mutating func getGenericSignature() -> swift.CanGenericSignature
    mutating func getRootType() -> swift.CanType
    mutating func getValueType() -> swift.CanType
    mutating func getNumOperands() -> UInt32
    mutating func getObjCString() -> llvm.StringRef
    mutating func getComponents() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponentEEE
    mutating func visitReferencedFunctionsAndMethods(_ functionCallBack: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift11SILFunctionEEEE, _ methodCallBack: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift10SILDeclRefEEEE)
    static func get(_ M: UnsafeMutablePointer<swift.SILModule>, _ signature: swift.CanGenericSignature, _ rootType: swift.CanType, _ valueType: swift.CanType, _ components: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponentEEE, _ ObjCString: llvm.StringRef) -> UnsafeMutablePointer<swift.KeyPathPattern>!
    static func Profile(_ ID: UnsafeMutablePointer<llvm.FoldingSetNodeID>, _ signature: swift.CanGenericSignature, _ rootType: swift.CanType, _ valueType: swift.CanType, _ components: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponentEEE, _ ObjCString: llvm.StringRef)
    mutating func Profile(_ ID: UnsafeMutablePointer<llvm.FoldingSetNodeID>)
  }

  /// The minimum unit of compilation.
  ///
  /// A module is made up of several file-units, which are all part of the same
  /// output binary and logical module (such as a single library or executable).
  ///
  /// \sa FileUnit
  struct ModuleDecl {

    /// Produces the components of a given module's full name in reverse order.
    ///
    /// For a Swift module, this will only ever have one component, but an
    /// imported Clang module might actually be a submodule.
    struct ReverseFullNameIterator {
      typealias difference_type = Int32
      typealias value_type = llvm.StringRef
      typealias pointer = UnsafeMutablePointer<llvm.StringRef>
      typealias reference = llvm.StringRef
      typealias iterator_category = std.__1.forward_iterator_tag
      init()
      init(_ M: UnsafePointer<swift.ModuleDecl>!)
      init(_ clangModule: UnsafePointer<clang.Module>!)
      static func * (lhs: inout swift.ModuleDecl.ReverseFullNameIterator) -> llvm.StringRef

      /// This is a convenience function that writes the entire name, in forward
      /// order, to \p out.
      mutating func printForward(_ out: UnsafeMutablePointer<llvm.raw_ostream>, _ delim: llvm.StringRef)
    }

    /// \sa getImportedModules
    enum ImportFilterKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32

      /// Include imports declared with `@_exported`.
      case Exported

      /// Include "regular" imports with no special annotation.
      case Default

      /// Include imports declared with `@_implementationOnly`.
      case ImplementationOnly

      /// Include imports of SPIs declared with `@_spi`
      case SPIAccessControl

      /// Include imports shadowed by a cross-import overlay. Unshadowed imports
      /// are included whether or not this flag is specified.
      case ShadowedByCrossImportOverlay
    }

    /// \sa getImportedModules
    typealias ImportFilter = swift.__CxxTemplateInstN5swift9OptionSetINS_10ModuleDecl16ImportFilterKindEjEE
    typealias LinkLibraryCallback = llvm.__CxxTemplateInstN4llvm12function_refIFvN5swift11LinkLibraryEEEE

    /// Creates a new module with a given \p name.
    ///
    /// \param importInfo Information about which modules should be implicitly
    /// imported by each file of this module.
    static func create(_ name: swift.Identifier, _ ctx: UnsafeMutablePointer<swift.ASTContext>, _ importInfo: swift.ImplicitImportInfo) -> UnsafeMutablePointer<swift.ModuleDecl>!
    static func createMainModule(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ name: swift.Identifier, _ iinfo: swift.ImplicitImportInfo) -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Retrieves information about which modules are implicitly imported by
    /// each file of this module.
    mutating func getImplicitImportInfo() -> UnsafePointer<swift.ImplicitImportInfo>

    /// Retrieve a list of modules that each file of this module implicitly
    /// imports.
    mutating func getImplicitImports() -> swift.ImplicitImportList
    mutating func getFiles() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift8FileUnitEEE
    mutating func getFiles() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPKN5swift8FileUnitEEE
    mutating func addFile(_ newFile: UnsafeMutablePointer<swift.FileUnit>)

    /// Add a file declaring a cross-import overlay.
    mutating func addCrossImportOverlayFile(_ file: llvm.StringRef)

    /// If this method returns \c false, the module does not declare any
    /// cross-import overlays.
    ///
    /// This is a quick check you can use to bail out of expensive logic early;
    /// however, a \c true return doesn't guarantee that the module declares
    /// cross-import overlays--it only means that it \em might declare some.
    ///
    /// (Specifically, this method checks if the module loader found any
    /// swiftoverlay files, but does not load the files to see if they list any
    /// overlay modules.)
    mutating func mightDeclareCrossImportOverlays() -> Bool

    /// Returns true if this module is an underscored cross import overlay
    /// declared by \p other or its underlying clang module, either directly or
    /// transitively (via intermediate cross-import overlays - for cross-imports
    /// involving more than two modules).
    mutating func isCrossImportOverlayOf(_ other: UnsafeMutablePointer<swift.ModuleDecl>!) -> Bool

    /// If this module is an underscored cross-import overlay, returns the
    /// non-underscored underlying module that declares it as an overlay, either
    /// directly or transitively (via intermediate cross-import overlays - for
    /// cross-imports involving more than two modules).
    mutating func getDeclaringModuleIfCrossImportOverlay() -> UnsafeMutablePointer<swift.ModuleDecl>!

    /// Walks and loads the declared, underscored cross-import overlays of this
    /// module and its underlying clang module, transitively, to find all cross
    /// import overlays this module underlies.
    ///
    /// This is used by tooling to present these overlays as part of this module.
    mutating func findDeclaredCrossImportOverlaysTransitive(_ overlays: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift10ModuleDeclEEE>)

    /// Convenience accessor for clients that know what kind of file they're
    /// dealing with.
    mutating func getMainSourceFile() -> UnsafeMutablePointer<swift.SourceFile>

    /// Convenience accessor for clients that know what kind of file they're
    /// dealing with.
    mutating func getMainFile(_ expectedKind: swift.FileUnitKind) -> UnsafeMutablePointer<swift.FileUnit>
    mutating func getDebugClient() -> OpaquePointer!
    mutating func setDebugClient(_ R: OpaquePointer!)

    /// Returns true if this module was or is being compiled for testing.
    mutating func isTestingEnabled() -> Bool
    mutating func setTestingEnabled(_ enabled: Bool)
    mutating func isImplicitDynamicEnabled() -> Bool
    mutating func setImplicitDynamicEnabled(_ enabled: Bool)

    /// Returns true if this module was or is begin compile with
    /// `-enable-private-imports`.
    mutating func arePrivateImportsEnabled() -> Bool
    mutating func setPrivateImportsEnabled(_ enabled: Bool)

    /// Returns true if there was an error trying to load this module.
    mutating func failedToLoad() -> Bool
    mutating func setFailedToLoad(_ failed: Bool)
    mutating func hasResolvedImports() -> Bool
    mutating func setHasResolvedImports()
    mutating func getResilienceStrategy() -> swift.ResilienceStrategy
    mutating func setResilienceStrategy(_ strategy: swift.ResilienceStrategy)

    /// Returns true if this module was or is being compiled for testing.
    mutating func hasIncrementalInfo() -> Bool
    mutating func setHasIncrementalInfo(_ enabled: Bool)

    /// \returns true if this module is a system module; note that the StdLib is
    /// considered a system module.
    mutating func isSystemModule() -> Bool
    mutating func setIsSystemModule(_ flag: Bool)

    /// Returns true if this module is a non-Swift module that was imported into
    /// Swift.
    ///
    /// Right now that's just Clang modules.
    mutating func isNonSwiftModule() -> Bool

    /// \see #isNonSwiftModule
    mutating func setIsNonSwiftModule(_ flag: Bool)
    mutating func isMainModule() -> Bool

    /// Retrieve the top-level module. If this module is already top-level, this
    /// returns itself. If this is a submodule such as \c Foo.Bar.Baz, this
    /// returns the module \c Foo.
    mutating func getTopLevelModule(_ overlay: Bool) -> UnsafeMutablePointer<swift.ModuleDecl>!
    mutating func isResilient() -> Bool

    /// Look up a (possibly overloaded) value set at top-level scope
    /// (but with the specified access path, which may come from an import decl)
    /// within the current module.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupValue(_ Name: swift.DeclName, _ LookupKind: swift.NLKind, _ Result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)

    /// Look up a local type declaration by its mangled name.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupLocalType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.TypeDecl>!

    /// Look up an opaque return type by the mangled name of the declaration
    /// that defines it.
    mutating func lookupOpaqueResultType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.OpaqueTypeDecl>!

    /// This is a hack for 'main' file parsing and the integrated REPL.
    ///
    /// FIXME: Refactor main file parsing to not pump the parser incrementally.
    /// FIXME: Remove the integrated REPL.
    mutating func clearLookupCache()

    /// Finds class members defined in this module with the given name.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    mutating func lookupClassMember(_ accessPath: swift.ImportPath.Access, _ name: swift.DeclName, _ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)

    /// Look for the conformance of the given type to the given protocol.
    ///
    /// This routine determines whether the given \c type conforms to the given
    /// \c protocol.
    ///
    /// \param type The type for which we are computing conformance.
    ///
    /// \param protocol The protocol to which we are computing conformance.
    ///
    /// \returns The result of the conformance search, which will be
    /// None if the type does not conform to the protocol or contain a
    /// ProtocolConformanceRef if it does conform.
    mutating func lookupConformance(_ type: swift.`Type`, _ protocol: UnsafeMutablePointer<swift.ProtocolDecl>!) -> swift.ProtocolConformanceRef

    /// Look for the conformance of the given existential type to the given
    /// protocol.
    mutating func lookupExistentialConformance(_ type: swift.`Type`, _ protocol: UnsafeMutablePointer<swift.ProtocolDecl>!) -> swift.ProtocolConformanceRef

    /// Exposes TypeChecker functionality for querying protocol conformance.
    /// Returns a valid ProtocolConformanceRef only if all conditional
    /// requirements are successfully resolved.
    mutating func conformsToProtocol(_ sourceTy: swift.`Type`, _ targetProtocol: UnsafeMutablePointer<swift.ProtocolDecl>!) -> swift.ProtocolConformanceRef

    /// Find a member named \p name in \p container that was declared in this
    /// module.
    ///
    /// \p container may be \c this for a top-level lookup.
    ///
    /// If \p privateDiscriminator is non-empty, only matching private decls are
    /// returned; otherwise, only non-private decls are returned.
    mutating func lookupMember(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>, _ container: UnsafeMutablePointer<swift.DeclContext>!, _ name: swift.DeclName, _ privateDiscriminator: swift.Identifier)
    mutating func loadFingerprint(_ IDC: UnsafePointer<swift.IterableDeclContext>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift11FingerprintEEE
    mutating func isImportedAsSPI(_ attr: UnsafePointer<swift.SpecializeAttr>!, _ targetDecl: UnsafePointer<swift.ValueDecl>!) -> Bool
    mutating func isImportedAsSPI(_ spiGroup: swift.Identifier, _ fromModule: UnsafePointer<swift.ModuleDecl>!) -> Bool

    /// Has \p module been imported via an '@_implementationOnly' import
    /// instead of another kind of import?
    ///
    /// This assumes that \p module was imported.
    mutating func isImportedImplementationOnly(_ module: UnsafePointer<swift.ModuleDecl>!) -> Bool

    /// Finds all top-level decls of this module.
    ///
    /// This does a simple local lookup, not recursively looking through imports.
    /// The order of the results is not guaranteed to be meaningful.
    mutating func getTopLevelDecls(_ Results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)
    mutating func getExportedPrespecializations(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)

    /// Finds all top-level decls that should be displayed to a client of this
    /// module.
    ///
    /// This includes types, variables, functions, and extensions.
    /// This does a simple local lookup, not recursively looking through imports.
    /// The order of the results is not guaranteed to be meaningful.
    ///
    /// This can differ from \c getTopLevelDecls, e.g. it returns decls from a
    /// shadowed clang module.
    mutating func getDisplayDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)

    /// Generate the list of libraries needed to link this module, based on its
    /// imports.
    mutating func collectLinkLibraries(_ callback: swift.ModuleDecl.LinkLibraryCallback)

    /// Get the path for the file that this module came from, or an empty
    /// string if this is not applicable.
    mutating func getModuleFilename() -> llvm.StringRef

    /// \returns true if this module is the "swift" standard library module.
    mutating func isStdlibModule() -> Bool

    /// \returns true if this module is the "SwiftShims" module;
    mutating func isSwiftShimsModule() -> Bool

    /// \returns true if this module is the "builtin" module.
    mutating func isBuiltinModule() -> Bool

    /// \returns true if this module is the "SwiftOnoneSupport" module;
    mutating func isOnoneSupportModule() -> Bool

    /// \returns true if this module is the "Foundation" module;
    mutating func isFoundationModule() -> Bool

    /// \returns true if this module has a main entry point.
    mutating func hasEntryPoint() -> Bool

    /// Returns the associated clang module if one exists.
    mutating func findUnderlyingClangModule() -> UnsafePointer<clang.Module>!

    /// Returns a generator with the components of this module's full,
    /// hierarchical name.
    ///
    /// For a Swift module, this will only ever have one component, but an
    /// imported Clang module might actually be a submodule.
    mutating func getReverseFullModuleName() -> swift.ModuleDecl.ReverseFullNameIterator
    mutating func getSourceRange() -> swift.SourceRange
    static func classof(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
  }

  /// A file containing Swift source code.
  ///
  /// This is a .swift or .sil file (or a virtual file, such as the contents of
  /// the REPL). Since it contains raw source, it must be type checked for IR
  /// generation.
  struct SourceFile {

    /// Flags that direct how the source file is parsed.
    enum ParsingFlags : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8

      /// Whether to disable delayed parsing for nominal type, extension, and
      /// function bodies.
      ///
      /// If set, type and function bodies will be parsed eagerly. Otherwise they
      /// will be lazily parsed when their contents is queried. This lets us avoid
      /// building AST nodes when they're not needed.
      ///
      /// This is set for primary files, since we want to type check all
      /// declarations and function bodies anyway, so there's no benefit in lazy
      /// parsing.
      case DisableDelayedBodies

      /// Whether to disable evaluating the conditions of #if decls.
      ///
      /// If set, #if decls are parsed as-is. Otherwise, the bodies of any active
      /// clauses are hoisted such that they become sibling nodes with the #if
      /// decl.
      ///
      /// FIXME: When condition evaluation moves to a later phase, remove this
      /// and the associated language option.
      case DisablePoundIfEvaluation

      /// Whether to build a syntax tree.
      case BuildSyntaxTree

      /// Whether to save the file's parsed tokens.
      case CollectParsedTokens

      /// Whether to compute the interface hash of the file.
      case EnableInterfaceHash

      /// Whether to suppress warnings when parsing. This is set for secondary
      /// files, as they get parsed multiple times.
      case SuppressWarnings
    }
    typealias ParsingOptions = swift.__CxxTemplateInstN5swift9OptionSetINS_10SourceFile12ParsingFlagsEhEE
    struct ASTStage_t : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }
    struct ImportQueryKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }

    /// A cache of syntax nodes that can be reused when creating the syntax tree
    /// for this file.
    var SyntaxParsingCache: OpaquePointer!

    /// The list of local type declarations in the source file.
    var LocalTypeDecls: llvm.__CxxTemplateInstN4llvm9SetVectorIPN5swift8TypeDeclENSt3__16vectorIS3_NS4_9allocatorIS3_EEEENS_8DenseSetIS3_NS_12DenseMapInfoIS3_EEEEEE

    /// A set of synthesized declarations that need to be type checked.
    var SynthesizedDecls: llvm.__CxxTemplateInstN4llvm11SmallVectorIPN5swift4DeclELj8EEE

    /// The list of functions defined in this file whose bodies have yet to be
    /// typechecked. They must be held in this list instead of eagerly validated
    /// because their bodies may force us to perform semantic checks of arbitrary
    /// complexity, and we currently cannot handle those checks in isolation. E.g.
    /// we cannot, in general, perform witness matching on singular requirements
    /// unless the entire conformance has been evaluated.
    var DelayedFunctions: std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift20AbstractFunctionDeclENS_9allocatorIS3_EEEE

    /// We might perform type checking on the same source file more than once,
    /// if its the main file or a REPL instance, so keep track of the last
    /// checked synthesized declaration to avoid duplicating work.
    var LastCheckedSynthesizedDecl: UInt32

    /// A mapping from Objective-C selectors to the methods that have
    /// those selectors.
    var ObjCMethods: llvm.__CxxTemplateInstN4llvm8DenseMapIN5swift12ObjCSelectorENS_13TinyPtrVectorIPNS1_20AbstractFunctionDeclEEENS_12DenseMapInfoIS2_EENS_6detail12DenseMapPairIS2_S6_EEEE

    /// List of Objective-C methods, which is used for checking unintended
    /// Objective-C overrides.
    var ObjCMethodList: std.__1.__CxxTemplateInstNSt3__16vectorIPN5swift20AbstractFunctionDeclENS_9allocatorIS3_EEEE

    /// List of optional @objc protocol requirements that have gone
    /// unsatisfied, which might conflict with other Objective-C methods.
    var ObjCUnsatisfiedOptReqs: std.__1.__CxxTemplateInstNSt3__16vectorINS_4pairIPN5swift11DeclContextEPNS2_20AbstractFunctionDeclEEENS_9allocatorIS7_EEEE

    /// List of Objective-C member conflicts we have found during type checking.
    var ObjCMethodConflicts: std.__1.__CxxTemplateInstNSt3__16vectorINS_5tupleIJPN5swift9ClassDeclENS2_12ObjCSelectorEbEEENS_9allocatorIS6_EEEE

    /// Describes what kind of file this is, which can affect some type checking
    /// and other behavior.
    var Kind: swift.SourceFileKind { get }

    /// Defines what phases of parsing and semantic analysis are complete for a
    /// source file.
    ///
    /// Only files that have been fully processed (i.e. type-checked) will be
    /// forwarded on to IRGen.
    var ASTStage: swift.SourceFile.ASTStage_t

    /// Virtual file paths declared by \c #sourceLocation(file:) declarations in
    /// this source file.
    var VirtualFilePaths: llvm.__CxxTemplateInstN4llvm11SmallVectorIN5swift7LocatedINS_9StringRefEEELj0EEE
    init(_ M: UnsafeMutablePointer<swift.ModuleDecl>, _ K: swift.SourceFileKind, _ bufferID: llvm.__CxxTemplateInstN4llvm8OptionalIjEE, _ parsingOpts: swift.SourceFile.ParsingOptions, _ isPrimary: Bool)

    /// Retrieve the parsing options specified in the LangOptions.
    static func getDefaultParsingOptions(_ langOpts: UnsafePointer<swift.LangOptions>) -> swift.SourceFile.ParsingOptions

    /// Appends the given declaration to the end of the top-level decls list. Do
    /// not add any additional uses of this function.
    mutating func addTopLevelDecl(_ d: UnsafeMutablePointer<swift.Decl>!)

    /// Prepends a declaration to the top-level decls list.
    ///
    /// FIXME: This entrypoint exists to support LLDB. Calls to this function are
    /// always a mistake, and additional uses should not be added.
    ///
    /// See rdar://58355191
    mutating func prependTopLevelDecl(_ d: UnsafeMutablePointer<swift.Decl>!)

    /// Add a hoisted declaration. See Decl::isHoisted().
    mutating func addHoistedDecl(_ d: UnsafeMutablePointer<swift.Decl>!)

    /// Retrieves an immutable view of the list of top-level decls in this file.
    mutating func getTopLevelDecls() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift4DeclEEE

    /// Retrieves an immutable view of the list of hoisted decls in this file.
    /// See Decl::isHoisted().
    mutating func getHoistedDecls() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift4DeclEEE

    /// Retrieves an immutable view of the top-level decls if they have already
    /// been parsed, or \c None if they haven't. Should only be used for dumping.
    mutating func getCachedTopLevelDecls() -> llvm.__CxxTemplateInstN4llvm8OptionalINS_8ArrayRefIPN5swift4DeclEEEEE

    /// Retrieve the parsing options for the file.
    mutating func getParsingOptions() -> swift.SourceFile.ParsingOptions

    /// Whether this source file is a primary file, meaning that we're generating
    /// code for it. Note this method returns \c false in WMO.
    mutating func isPrimary() -> Bool

    /// Retrieve an immutable view of the source file's imports.
    mutating func getImports() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift16AttributedImportINS1_14ImportedModuleEEEEE

    /// Set the imports for this source file. This gets called by import
    /// resolution.
    mutating func setImports(_ imports: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift16AttributedImportINS1_14ImportedModuleEEEEE)
    mutating func hasTestableOrPrivateImport(_ accessLevel: swift.AccessLevel, _ ofDecl: UnsafePointer<swift.ValueDecl>!, _ kind: swift.SourceFile.ImportQueryKind) -> Bool

    /// Does this source file have any implementation-only imports?
    /// If not, we can fast-path module checks.
    mutating func hasImplementationOnlyImports() -> Bool
    mutating func isImportedImplementationOnly(_ module: UnsafePointer<swift.ModuleDecl>!) -> Bool
    mutating func isImportedAsSPI(_ targetDecl: UnsafePointer<swift.ValueDecl>!) -> Bool
    mutating func shouldCrossImport() -> Bool

    /// Register a separately-imported overlay as shadowing the module that
    /// declares it.
    ///
    /// \returns true if the overlay was added; false if it already existed.
    mutating func addSeparatelyImportedOverlay(_ overlay: UnsafeMutablePointer<swift.ModuleDecl>!, _ declaring: UnsafeMutablePointer<swift.ModuleDecl>!) -> Bool

    /// Retrieves a list of separately imported overlays which are shadowing
    /// \p declaring. If any \p overlays are returned, qualified lookups into
    /// \p declaring should be performed into \p overlays instead; since they
    /// are overlays, they will re-export \p declaring, but will also augment it
    /// with additional symbols.
    mutating func getSeparatelyImportedOverlays(_ declaring: UnsafeMutablePointer<swift.ModuleDecl>!, _ overlays: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift10ModuleDeclEEE>)
    @available(*, deprecated, message: "only for use in the debugger")
    mutating func dumpSeparatelyImportedOverlays()
    mutating func cacheVisibleDecls(_ globals: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)
    mutating func getCachedVisibleDecls() -> UnsafePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>
    mutating func lookupValue(_ name: swift.DeclName, _ lookupKind: swift.NLKind, _ result: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)
    mutating func lookupClassMember(_ accessPath: swift.ImportPath.Access, _ name: swift.DeclName, _ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift9ValueDeclEEE>)
    mutating func getTopLevelDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift4DeclEEE>)
    mutating func lookupLocalType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.TypeDecl>!
    mutating func getOpaqueReturnTypeDecls(_ results: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIPN5swift14OpaqueTypeDeclEEE>)
    mutating func collectLinkLibraries(_ callback: swift.ModuleDecl.LinkLibraryCallback)
    mutating func getDiscriminatorForPrivateValue(_ D: UnsafePointer<swift.ValueDecl>!) -> swift.Identifier
    mutating func getPrivateDiscriminator() -> swift.Identifier
    mutating func getBasicLocsForDecl(_ D: UnsafePointer<swift.Decl>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13BasicDeclLocsEEE

    /// Returns the synthesized file for this source file, if it exists.
    mutating func getSynthesizedFile() -> UnsafeMutablePointer<swift.SynthesizedFileUnit>!
    mutating func getOrCreateSynthesizedFile() -> UnsafeMutablePointer<swift.SynthesizedFileUnit>

    /// The buffer ID for the file that was imported, or None if there
    /// is no associated buffer.
    mutating func getBufferID() -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE

    /// If this buffer corresponds to a file on disk, returns the path.
    /// Otherwise, return an empty string.
    mutating func getFilename() -> llvm.StringRef
    mutating func clearScope()

    /// Retrieves the previously set delayed parser state, asserting that it
    /// exists.
    mutating func getDelayedParserState() -> OpaquePointer!

    /// Record delayed parser state for the source file. This is needed for code
    /// completion's second pass.
    mutating func setDelayedParserState(_ state: UnsafeMutablePointer<std.__1.__CxxTemplateInstNSt3__110unique_ptrIN5swift21PersistentParserStateEPFvPS2_EEE>)
    @available(*, deprecated, message: "only for use in the debugger")
    mutating func dump()
    mutating func dump(_ os: UnsafeMutablePointer<llvm.raw_ostream>, _ parseIfNeeded: Bool)
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ PO: UnsafePointer<swift.PrintOptions>)
    static func classof(_ file: UnsafePointer<swift.FileUnit>!) -> Bool
    static func classof(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool

    /// True if this is a "script mode" source file that admits top-level code.
    mutating func isScriptMode() -> Bool
    mutating func getMainDecl() -> UnsafeMutablePointer<swift.Decl>!
    mutating func getMainDeclDiagLoc() -> swift.SourceLoc
    mutating func getMainClassDiagLoc() -> swift.SourceLoc

    /// Register a "main" class for the module, complaining if there is more than
    /// one.
    ///
    /// Should only be called during type-checking.
    mutating func registerMainDecl(_ mainDecl: UnsafeMutablePointer<swift.Decl>!, _ diagLoc: swift.SourceLoc) -> Bool

    /// True if this source file has an application entry point.
    ///
    /// This is true if the source file either is in script mode or contains
    /// a designated main class.
    mutating func hasEntryPoint() -> Bool

    /// Get the root refinement context for the file. The root context may be
    /// null if the context hierarchy has not been built yet. Use
    /// TypeChecker::getOrBuildTypeRefinementContext() to get a built
    /// root of the hierarchy.
    mutating func getTypeRefinementContext() -> OpaquePointer!

    /// Set the root refinement context for the file.
    mutating func setTypeRefinementContext(_ TRC: OpaquePointer!)

    /// Whether this file has an interface hash available.
    mutating func hasInterfaceHash() -> Bool

    /// Output this file's interface hash into the provided string buffer.
    mutating func getInterfaceHash() -> swift.Fingerprint
    mutating func dumpInterfaceHash(_ out: UnsafeMutablePointer<llvm.raw_ostream>)

    /// If this source file has been told to collect its parsed tokens, retrieve
    /// those tokens.
    mutating func getAllTokens() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift5TokenEEE

    /// Whether the parsed tokens of this source file should be saved, allowing
    /// them to be accessed from \c getAllTokens.
    mutating func shouldCollectTokens() -> Bool
    mutating func shouldBuildSyntaxTree() -> Bool

    /// Whether the bodies of types and functions within this file can be lazily
    /// parsed.
    mutating func hasDelayedBodyParsing() -> Bool
    mutating func lookupOpaqueResultType(_ MangledName: llvm.StringRef) -> UnsafeMutablePointer<swift.OpaqueTypeDecl>!

    /// Do not call when inside an inactive clause (\c
    /// InInactiveClauseEnvironment)) because it will later on result in a lookup
    /// to something that won't be in the ASTScope tree.
    mutating func addUnvalidatedDeclWithOpaqueResultType(_ vd: UnsafeMutablePointer<swift.ValueDecl>!)
  }

  /// A stage of SIL processing.
  enum SILStage : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32

    /// "Raw" SIL, emitted by SILGen, but not yet run through guaranteed
    /// optimization and diagnostic passes.
    ///
    /// Raw SIL does not have fully-constructed SSA and may contain undiagnosed
    /// dataflow errors.
    case Raw

    /// Canonical SIL, which has been run through at least the guaranteed
    /// optimization and diagnostic passes.
    ///
    /// Canonical SIL has stricter invariants than raw SIL. It must not contain
    /// dataflow errors, and some instructions must be canonicalized to simpler
    /// forms.
    case Canonical

    /// Lowered SIL, which has been prepared for IRGen and will no longer
    /// be passed to canonical SIL transform passes.
    ///
    /// In lowered SIL, the SILType of all SILValues is its SIL storage
    /// type. Explicit storage is required for all address-only and resilient
    /// types.
    ///
    /// Generating the initial Raw SIL is typically referred to as lowering (from
    /// the AST). To disambiguate, refer to the process of generating the lowered
    /// stage of SIL as "address lowering".
    case Lowered
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, M: UnsafePointer<swift.SILModule>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Print a simple description of a SILModule for the request evaluator.
  static func simple_display(_ out: UnsafeMutablePointer<llvm.raw_ostream>, _ M: UnsafePointer<swift.SILModule>!)

  /// Retrieve a SourceLoc for a SILModule that the request evaluator can use for
  /// diagnostics.
  static func extractNearestSourceLoc(_ SM: UnsafePointer<swift.SILModule>!) -> swift.SourceLoc
  enum Bridgeability : UInt32 {
    init?(rawValue: UInt32)
    var rawValue: UInt32 { get }
    typealias RawValue = UInt32

    /// This context does not permit bridging at all.  For example, the
    /// target of a C pointer.
    case None

    /// This context permits all kinds of bridging.  For example, the
    /// imported result of a method declaration.
    case Full
  }

  /// Is an operation an "initialization"?  An initialization simply
  /// fills in an uninitialized address with a value; a
  /// non-initialization also consumes the value already there.
  struct IsInitialization_t : Equatable, RawRepresentable {
    init(_ rawValue: Bool)
    init(rawValue: Bool)
    var rawValue: Bool
    typealias RawValue = Bool
  }

  /// Is an operation a "take"?  A take consumes the original value,
  /// leaving it uninitialized.
  struct IsTake_t : Equatable, RawRepresentable {
    init(_ rawValue: Bool)
    init(rawValue: Bool)
    var rawValue: Bool
    typealias RawValue = Bool
  }

  /// This is a pointer to the AST node that a SIL instruction was
  /// derived from. This may be null if AST information is unavailable or
  /// stripped.
  ///
  /// FIXME: This should eventually include inlining history, generics
  /// instantiation info, etc (when we get to it).
  ///
  struct SILLocation {
    struct LocationKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }
    struct StorageKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }
    struct DebugLoc {
      var Line: UInt32
      var Column: UInt32
      var Filename: llvm.StringRef
      init(_ Line: UInt32, _ Column: UInt32, _ Filename: llvm.StringRef)
      static func == (lhs: inout swift.SILLocation.DebugLoc, R: UnsafePointer<swift.SILLocation.DebugLoc>) -> Bool
    }

    /// Fingerprint a DebugLoc for use in a DenseMap.
    typealias DebugLocKey = std.__1.__CxxTemplateInstNSt3__14pairINS0_IjjEEN4llvm9StringRefEEE
    struct DebugLocHash {
      init(_ L: swift.SILLocation.DebugLoc)
    }

    /// When an ASTNode gets implicitly converted into a SILLocation we
    /// construct a RegularLocation. Since RegularLocations represent the majority
    /// of locations, this greatly simplifies the user code.
    init(_ S: OpaquePointer!)
    init(_ E: OpaquePointer!)
    init(_ D: UnsafeMutablePointer<swift.Decl>!)
    init(_ P: OpaquePointer!)
    static func invalid() -> swift.SILLocation

    /// Check if the location wraps an AST node or a valid SIL file
    /// location.
    ///
    /// Artificial locations and the top-level module locations will be null.
    mutating func isNull() -> Bool

    /// Return whether this location is backed by an AST node.
    mutating func isASTNode() -> Bool

    /// Return whether this location came from a SIL file.
    mutating func isSILFile() -> Bool

    /// Return whether this location came from a textual SIL file.
    mutating func isDebugInfoLoc() -> Bool

    /// Marks the location as coming from auto-generated body.
    mutating func markAutoGenerated()

    /// Returns true if the location represents an artificially generated
    /// body, such as thunks or default destructors.
    ///
    /// These locations should not be included in the debug line table.
    /// These might also need special handling by the debugger since they might
    /// contain calls, which the debugger could be able to step into.
    mutating func isAutoGenerated() -> Bool

    /// Returns true if the line number of this location is zero.
    mutating func isLineZero(_ SM: UnsafePointer<swift.SourceManager>) -> Bool

    /// Changes the default source location position to point to start of
    /// the AST node.
    mutating func pointToStart()

    /// Changes the default source location position to point to the end of
    /// the AST node.
    mutating func pointToEnd()

    /// Mark this location as the location corresponding to the top-level
    /// (module-level) code.
    mutating func markAsInTopLevel()

    /// Check is this location is associated with the top level/module.
    mutating func isInTopLevel() -> Bool

    /// Mark this location as being part of the function
    /// prologue, which means that it deals with setting up the stack
    /// frame. The first breakpoint location in a function is at the end
    /// of the prologue.
    mutating func markAsPrologue()

    /// Check is this location is part of a function's implicit prologue.
    mutating func isInPrologue() -> Bool

    /// Add an ASTNode to use as the location for debugging
    /// purposes if this location is different from the location used
    /// for diagnostics.
    mutating func setDebugLoc<T>(_ ASTNodeForDebugging: OpaquePointer!)
    mutating func hasDebugLoc() -> Bool

    /// Populate this empty SILLocation with a DebugLoc.
    mutating func setDebugInfoLoc(_ L: swift.SILLocation.DebugLoc)

    /// Check if the corresponding source code location definitely points
    ///  to the start of the AST node.
    mutating func alwaysPointsToStart() -> Bool

    /// Check if the corresponding source code location definitely points
    ///  to the end of the AST node.
    mutating func alwaysPointsToEnd() -> Bool
    mutating func getKind() -> swift.SILLocation.LocationKind
    mutating func getStorageKind() -> swift.SILLocation.StorageKind
    mutating func `is`<T>() -> Bool
    mutating func castTo<T>() -> T

    /// If the current value is of the specified AST unit type T,
    /// return it, otherwise return null.
    mutating func getAsASTNode<T>() -> OpaquePointer!

    /// Returns true if the Location currently points to the AST node
    /// matching type T.
    mutating func isASTNode<T>() -> Bool

    /// Returns the primary value as the specified AST node type. If the
    /// specified type is incorrect, asserts.
    mutating func castToASTNode<T>() -> OpaquePointer!

    /// If the DebugLoc is of the specified AST unit type T,
    /// return it, otherwise return null.
    mutating func getDebugLocAsASTNode<T>() -> OpaquePointer!

    /// Return the location as a DeclContext or null.
    mutating func getAsDeclContext() -> UnsafeMutablePointer<swift.DeclContext>!

    /// Convert a specialized location kind into a regular location.
    mutating func getAsRegularLocation() -> swift.SILLocation
    mutating func getDebugSourceLoc() -> swift.SourceLoc
    mutating func getSourceLoc() -> swift.SourceLoc
    mutating func getStartSourceLoc() -> swift.SourceLoc
    mutating func getEndSourceLoc() -> swift.SourceLoc
    mutating func getSourceRange() -> swift.SourceRange
    mutating func getDebugInfoLoc() -> swift.SILLocation.DebugLoc

    /// Extract the line, column, and filename.
    static func decode(_ Loc: swift.SourceLoc, _ SM: UnsafePointer<swift.SourceManager>) -> swift.SILLocation.DebugLoc

    /// Return the decoded debug location.
    mutating func decodeDebugLoc(_ SM: UnsafePointer<swift.SourceManager>) -> swift.SILLocation.DebugLoc

    /// Compiler-generated locations may be applied to instructions without any
    /// clear correspondence to an AST node in an otherwise normal function.
    static func getCompilerGeneratedDebugLoc() -> swift.SILLocation.DebugLoc

    /// Pretty-print the value.
    mutating func dump(_ SM: UnsafePointer<swift.SourceManager>)
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ SM: UnsafePointer<swift.SourceManager>)

    /// Returns an opaque pointer value for the debug location that may
    /// be used to unique debug locations.
    mutating func getOpaquePointerValue() -> UnsafeRawPointer!
    mutating func getOpaqueKind() -> UInt32
    static func == (lhs: inout swift.SILLocation, R: UnsafePointer<swift.SILLocation>) -> Bool
    static func != (lhs: inout swift.SILLocation, R: UnsafePointer<swift.SILLocation>) -> Bool
  }

  /// ValueDecl - All named decls that are values in the language.  These can
  /// have a type, etc.
  struct ValueDecl {

    /// Return true if this protocol member is a protocol requirement.
    ///
    /// Asserts if this is not a member of a protocol.
    mutating func isProtocolRequirement() -> Bool
    mutating func setUserAccessible(_ Accessible: Bool)
    mutating func isUserAccessible() -> Bool
    mutating func hasName() -> Bool
    mutating func isOperator() -> Bool

    /// Retrieve the full name of the declaration.
    mutating func getName() -> swift.DeclName
    mutating func setName(_ name: swift.DeclName)

    /// Retrieve the base name of the declaration, ignoring any argument
    /// names.
    mutating func getBaseName() -> swift.DeclBaseName
    mutating func getBaseIdentifier() -> swift.Identifier

    /// Generates a DeclNameRef referring to this declaration with as much
    /// specificity as possible.
    mutating func createNameRef() -> swift.DeclNameRef

    /// Retrieve the name to use for this declaration when interoperating
    /// with the Objective-C runtime.
    ///
    /// \returns A "selector" containing the runtime name. For non-method
    /// entities (classes, protocols, properties), this operation will
    /// return a zero-parameter selector with the appropriate name in its
    /// first slot.
    mutating func getObjCRuntimeName(_ skipIsObjCResolution: Bool) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift12ObjCSelectorEEE

    /// Determine whether the given declaration can infer @objc, or the
    /// Objective-C name, if used to satisfy the given requirement.
    mutating func canInferObjCFromRequirement(_ requirement: UnsafeMutablePointer<swift.ValueDecl>!) -> Bool
    mutating func getNameLoc() -> swift.SourceLoc
    mutating func isUsableFromInline() -> Bool

    /// Returns \c true if this declaration is *not* intended to be used directly
    /// by application developers despite the visibility.
    mutating func shouldHideFromEditor() -> Bool
    mutating func hasAccess() -> Bool

    /// Returns the access level specified explicitly by the user, or provided by
    /// default according to language rules.
    ///
    /// Most of the time this is not the interesting value to check; access is
    /// limited by enclosing scopes per SE-0025. Use #getFormalAccessScope to
    /// check if access control is being used consistently, and to take features
    /// such as \c \@testable and \c \@usableFromInline into account.
    ///
    /// \sa getFormalAccessScope
    /// \sa hasOpenAccess
    mutating func getFormalAccess() -> swift.AccessLevel

    /// Determine whether this Decl has either Private or FilePrivate access,
    /// and its DeclContext does not.
    mutating func isOutermostPrivateOrFilePrivateScope() -> Bool

    /// Returns the outermost DeclContext from which this declaration can be
    /// accessed, or null if the declaration is public.
    ///
    /// This is used when calculating if access control is being used
    /// consistently. If \p useDC is provided (the location where the value is
    /// being used), features that affect formal access such as \c \@testable are
    /// taken into account.
    ///
    /// \invariant
    /// <code>value.isAccessibleFrom(
    ///     value.getFormalAccessScope().getDeclContext())</code>
    ///
    /// If \p treatUsableFromInlineAsPublic is true, declarations marked with the
    /// \c \@usableFromInline attribute are treated as public. This is normally
    /// false for name lookup and other source language concerns, but true when
    /// computing the linkage of generated functions.
    ///
    /// \sa getFormalAccess
    /// \sa isAccessibleFrom
    /// \sa hasOpenAccess
    mutating func getFormalAccessScope(_ useDC: UnsafePointer<swift.DeclContext>!, _ treatUsableFromInlineAsPublic: Bool) -> swift.AccessScope

    /// Copy the formal access level and @usableFromInline attribute from
    /// \p source.
    ///
    /// If \p sourceIsParentContext is true, an access level of \c private will
    /// be copied as \c fileprivate, to ensure that this declaration will be
    /// available everywhere \p source is.
    mutating func copyFormalAccessFrom(_ source: UnsafePointer<swift.ValueDecl>!, _ sourceIsParentContext: Bool)

    /// Returns the access level that actually controls how a declaration should
    /// be emitted and may be used.
    ///
    /// This is the access used when making optimization and code generation
    /// decisions. It should not be used at the AST or semantic level.
    mutating func getEffectiveAccess() -> swift.AccessLevel
    mutating func setAccess(_ access: swift.AccessLevel)

    /// Overwrite the access of this declaration.
    ///
    /// This is needed in the LLDB REPL.
    mutating func overwriteAccess(_ access: swift.AccessLevel)

    /// Returns true if this declaration is accessible from the given context.
    ///
    /// A private declaration is accessible from any DeclContext within the same
    /// source file.
    ///
    /// An internal declaration is accessible from any DeclContext within the same
    /// module.
    ///
    /// A public declaration is accessible everywhere.
    ///
    /// If \p DC is null, returns true only if this declaration is public.
    ///
    /// If \p forConformance is true, we ignore the visibility of the protocol
    /// when evaluating protocol extension members. This language rule allows a
    /// protocol extension of a private protocol to provide default
    /// implementations for the requirements of a public protocol, even when
    /// the default implementations are not visible to name lookup.
    mutating func isAccessibleFrom(_ DC: UnsafePointer<swift.DeclContext>!, _ forConformance: Bool, _ allowUsableFromInline: Bool) -> Bool

    /// Returns whether this declaration should be treated as \c open from
    /// \p useDC. This is very similar to #getFormalAccess, but takes
    /// \c \@testable into account.
    ///
    /// This is mostly only useful when considering requirements on an override:
    /// if the base declaration is \c open, the override might have to be too.
    mutating func hasOpenAccess(_ useDC: UnsafePointer<swift.DeclContext>!) -> Bool

    /// FIXME: This is deprecated.
    mutating func isRecursiveValidation() -> Bool

    /// Retrieve the "interface" type of this value, which uses
    /// GenericTypeParamType if the declaration is generic. For a generic
    /// function, this will have a GenericFunctionType with a
    /// GenericSignature inside the type.
    mutating func getInterfaceType() -> swift.`Type`
    mutating func hasInterfaceType() -> Bool

    /// Set the interface type for the given value.
    mutating func setInterfaceType(_ type: swift.`Type`)

    /// isInstanceMember - Determine whether this value is an instance member
    /// of an enum or protocol.
    mutating func isInstanceMember() -> Bool

    /// Retrieve the context discriminator for this local value, which
    /// is the index of this declaration in the sequence of
    /// discriminated declarations with the same name in the current
    /// context.  Only local functions and variables with getters and
    /// setters have discriminators.
    mutating func getLocalDiscriminator() -> UInt32
    mutating func setLocalDiscriminator(_ index: UInt32)

    /// Retrieve the declaration that this declaration overrides, if any.
    mutating func getOverriddenDecl() -> UnsafeMutablePointer<swift.ValueDecl>!

    /// Retrieve the declarations that this declaration overrides, if any.
    mutating func getOverriddenDecls() -> llvm.__CxxTemplateInstN4llvm13TinyPtrVectorIPN5swift9ValueDeclEEE

    /// Set the declaration that this declaration overrides.
    mutating func setOverriddenDecl(_ overridden: UnsafeMutablePointer<swift.ValueDecl>!)

    /// Set the declarations that this declaration overrides.
    mutating func setOverriddenDecls(_ overridden: llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9ValueDeclEEE)

    /// Whether the overridden declarations have already been computed.
    mutating func overriddenDeclsComputed() -> Bool

    /// Compute the untyped overload signature for this declaration.
    mutating func getOverloadSignature() -> swift.OverloadSignature

    /// Retrieve the type used to describe this entity for the purposes of
    /// overload resolution.
    mutating func getOverloadSignatureType() -> swift.CanType

    /// Returns true if the decl requires Objective-C interop.
    ///
    /// This can be true even if there is no 'objc' attribute on the declaration.
    /// In that case it was inferred by the type checker and set with a call to
    /// markAsObjC().
    mutating func isObjC() -> Bool

    /// Note whether this declaration is known to be exposed to Objective-C.
    mutating func setIsObjC(_ Value: Bool)

    /// Is this declaration 'final'?
    mutating func isFinal() -> Bool

    /// Is this declaration marked with 'dynamic'?
    mutating func isDynamic() -> Bool

    /// Should we use Objective-C method dispatch for this decl.
    mutating func shouldUseObjCDispatch() -> Bool

    /// Should we use native dynamic function replacement dispatch for this decl.
    mutating func shouldUseNativeDynamicDispatch() -> Bool

    /// Should we use Objective-C category based function replacement for this
    /// decl.
    /// This is all `@objc dynamic` methods except for such methods in native
    /// generic classes. We can't use a category for generic classes so we use
    /// native replacement instead (this behavior is only enabled with
    /// -enable-implicit-dynamic).
    mutating func shouldUseObjCMethodReplacement() -> Bool

    /// Should we use native dynamic function replacement mechanism for this decl.
    /// This is all native dynamic methods except for `@objc dynamic` methods in
    /// generic classes (see above).
    mutating func shouldUseNativeMethodReplacement() -> Bool

    /// Is this a native dynamic function replacement based replacement.
    /// This is all @_dynamicReplacement(for:) of native functions and @objc
    /// dynamic methods on generic classes (see above).
    mutating func isNativeMethodReplacement() -> Bool
    mutating func isEffectiveLinkageMoreVisibleThan(_ other: UnsafeMutablePointer<swift.ValueDecl>!) -> Bool

    /// Set whether this type is 'dynamic' or not.
    mutating func setIsDynamic(_ value: Bool)

    /// Whether the 'dynamic' bit has been computed already.
    mutating func isDynamicComputed() -> Bool

    /// Returns true if this decl can be found by id-style dynamic lookup.
    mutating func canBeAccessedByDynamicLookup() -> Bool

    /// Returns true if this declaration has an implicitly unwrapped optional
    /// result. The precise meaning depends on the declaration kind:
    /// - for properties, the value is IUO
    /// - for subscripts, the element type is IUO
    /// - for functions, the result type is IUO
    /// - for constructors, the failability kind is IUO
    mutating func isImplicitlyUnwrappedOptional() -> Bool

    /// Should only be set on imported and deserialized declarations; parsed
    /// declarations compute this lazily via a request.
    mutating func setImplicitlyUnwrappedOptional(_ isIUO: Bool)

    /// Returns the protocol requirements that this decl conforms to.
    mutating func getSatisfiedProtocolRequirements(_ Sorted: Bool) -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift9ValueDeclEEE

    /// Determines if a reference to this declaration from a nested function
    /// should be treated like a capture of a local value.
    mutating func isLocalCapture() -> Bool

    /// Dump a reference to the given declaration.
    mutating func dumpRef(_ os: UnsafeMutablePointer<llvm.raw_ostream>)
    @available(*, deprecated, message: "only for use in the debugger")
    mutating func dumpRef()

    /// Returns true if the declaration is a static member of a type.
    ///
    /// This is not necessarily the opposite of "isInstanceMember()". Both
    /// predicates will be false for declarations that either categorically
    /// can't be "static" or are in a context where "static" doesn't make sense.
    mutating func isStatic() -> Bool

    /// Retrieve the location at which we should insert a new attribute or
    /// modifier.
    mutating func getAttributeInsertionLoc(_ forModifier: Bool) -> swift.SourceLoc
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool

    /// True if this is a C function that was imported as a member of a type in
    /// Swift.
    mutating func isImportAsMember() -> Bool

    /// Returns true if the declaration's interface type is a function type with a
    /// curried self parameter.
    mutating func hasCurriedSelf() -> Bool

    /// Returns true if the declaration has a parameter list associated with it.
    ///
    /// Note that not all declarations with function interface types have
    /// parameter lists, for example an enum element without associated values.
    mutating func hasParameterList() -> Bool

    /// Returns the number of curry levels in the declaration's interface type.
    mutating func getNumCurryLevels() -> UInt32

    /// Get the decl for this value's opaque result type, if it has one.
    mutating func getOpaqueResultTypeDecl() -> UnsafeMutablePointer<swift.OpaqueTypeDecl>!

    /// Get the representative for this value's opaque result type, if it has one.
    mutating func getOpaqueResultTypeRepr() -> OpaquePointer!

    /// Retrieve the attribute associating this declaration with a
    /// result builder, if there is one.
    mutating func getAttachedResultBuilder() -> UnsafeMutablePointer<swift.CustomAttr>!

    /// Retrieve the @resultBuilder type attached to this declaration,
    /// if there is one.
    mutating func getResultBuilderType() -> swift.`Type`

    /// If this value or its backing storage is annotated
    /// @_dynamicReplacement(for: ...), compute the original declaration
    /// that this declaration dynamically replaces.
    mutating func getDynamicallyReplacedDecl() -> UnsafeMutablePointer<swift.ValueDecl>!
  }

  /// Identifiers for protocol method dispatch strategies.
  enum ProtocolDispatchStrategy : UInt8 {
    init?(rawValue: UInt8)
    var rawValue: UInt8 { get }
    typealias RawValue = UInt8

    /// Uses ObjC method dispatch.
    ///
    /// This must be 0 for ABI compatibility with Objective-C protocol_t records.
    case ObjC

    /// Uses Swift protocol witness table dispatch.
    ///
    /// To invoke methods of this protocol, a pointer to a protocol witness table
    /// corresponding to the protocol conformance must be available.
    case Swift
  }

  /// Does a protocol using the given strategy require a witness table?
  static func protocolRequiresWitnessTable(_ strategy: swift.ProtocolDispatchStrategy) -> Bool

  /// Related to linkage: flag if a function or global variable is serialized,
  /// either unconditionally, or if referenced from another serialized function.
  struct IsSerialized_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt8)
    init(rawValue: UInt8)
    var rawValue: UInt8
    typealias RawValue = UInt8
  }
  struct SILVTableEntry {
    struct Kind : Equatable, RawRepresentable {
      init(_ rawValue: UInt8)
      init(rawValue: UInt8)
      var rawValue: UInt8
      typealias RawValue = UInt8
    }
    init()
    init(_ Method: swift.SILDeclRef, _ Implementation: UnsafeMutablePointer<swift.SILFunction>!, _ TheKind: swift.SILVTableEntry.Kind, _ NonOverridden: Bool)
    mutating func getMethod() -> swift.SILDeclRef
    mutating func getKind() -> swift.SILVTableEntry.Kind
    mutating func setKind(_ kind: swift.SILVTableEntry.Kind)
    mutating func isNonOverridden() -> Bool
    mutating func setNonOverridden(_ value: Bool)
    mutating func getImplementation() -> UnsafeMutablePointer<swift.SILFunction>!
    @warn_unqualified_access
    mutating func print(_ os: UnsafeMutablePointer<llvm.raw_ostream>)
    static func == (lhs: inout swift.SILVTableEntry, e: UnsafePointer<swift.SILVTableEntry>) -> Bool
    static func != (lhs: inout swift.SILVTableEntry, e: UnsafePointer<swift.SILVTableEntry>) -> Bool
  }

  /// A mapping from each dynamically-dispatchable method of a class to the
  /// SILFunction that implements the method for that class.
  /// Note that dead methods are completely removed from the vtable.
  struct SILVTable {
    typealias Entry = swift.SILVTableEntry

    /// Create a new SILVTable with the given method-to-implementation mapping.
    /// The SILDeclRef keys should reference the most-overridden members available
    /// through the class.
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Class: UnsafeMutablePointer<swift.ClassDecl>!, _ Serialized: swift.IsSerialized_t, _ Entries: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift14SILVTableEntryEEE) -> UnsafeMutablePointer<swift.SILVTable>!

    /// Return the class that the vtable represents.
    mutating func getClass() -> UnsafeMutablePointer<swift.ClassDecl>!

    /// Returns true if this vtable is going to be (or was) serialized.
    mutating func isSerialized() -> swift.IsSerialized_t

    /// Sets the serialized flag.
    mutating func setSerialized(_ serialized: swift.IsSerialized_t)

    /// Return all of the method entries.
    mutating func getEntries() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift14SILVTableEntryEEE

    /// Return all of the method entries mutably.
    /// If you do modify entries, make sure to invoke `updateVTableCache` to update the
    /// SILModule's cache entry.
    mutating func getMutableEntries() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift14SILVTableEntryEEE
    mutating func updateVTableCache(_ entry: UnsafePointer<swift.SILVTable.Entry>)

    /// Removes entries from the vtable.
    /// \p predicate Returns true if the passed entry should be removed.
    mutating func removeEntries_if<Predicate>(_ predicate: Predicate)

    /// Verify that the vtable is well-formed for the given class.
    mutating func verify(_ M: UnsafePointer<swift.SILModule>)

    /// Print the vtable.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool)
    mutating func dump()
  }

  /// Used as context for the SIL print functions.
  struct SILPrintContext {
    struct ID {
      struct ID_Kind : Equatable, RawRepresentable {
        init(_ rawValue: UInt32)
        init(rawValue: UInt32)
        var rawValue: UInt32
        typealias RawValue = UInt32
      }
      var Kind: swift.SILPrintContext.ID.ID_Kind
      var Number: UInt32
      init()
      init(Kind: swift.SILPrintContext.ID.ID_Kind, Number: UInt32)
      static func < (lhs: inout swift.SILPrintContext.ID, Other: swift.SILPrintContext.ID) -> Bool
      @warn_unqualified_access
      mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
    }

    /// Constructor with default values for options.
    ///
    /// DebugInfo will be set according to the -sil-print-debuginfo option.
    init(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool, _ SortedSIL: Bool, _ PrintFullConvention: Bool)

    /// Constructor based on SILOptions.
    ///
    /// DebugInfo will be set according to the -sil-print-debuginfo option.
    init(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Opts: UnsafePointer<swift.SILOptions>)
    init(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool, _ SortedSIL: Bool, _ DebugInfo: Bool, _ PrintFullConvention: Bool)
    mutating func setContext(_ FunctionOrBlock: UnsafeRawPointer!)

    /// Returns the output stream for printing.
    mutating func OS() -> UnsafeMutablePointer<llvm.raw_ostream>

    /// Returns true if the SIL output should be sorted.
    mutating func sortSIL() -> Bool

    /// Returns true if verbose SIL should be printed.
    mutating func printVerbose() -> Bool

    /// Returns true if debug locations and scopes should be printed.
    mutating func printDebugInfo() -> Bool

    /// Returns true if the entire @convention(c, cType: ..) should be printed.
    mutating func printFullConvention() -> Bool
    mutating func getID(_ Block: UnsafePointer<swift.SILBasicBlock>!) -> swift.SILPrintContext.ID
    mutating func getID(_ node: UnsafePointer<swift.SILNode>!) -> swift.SILPrintContext.ID

    /// Returns true if the \p Scope has and ID assigned.
    mutating func hasScopeID(_ Scope: UnsafePointer<swift.SILDebugScope>!) -> Bool

    /// Returns the ID of \p Scope.
    mutating func getScopeID(_ Scope: UnsafePointer<swift.SILDebugScope>!) -> UInt32

    /// Assigns the next available ID to \p Scope.
    mutating func assignScopeID(_ Scope: UnsafePointer<swift.SILDebugScope>!) -> UInt32

    /// Callback which is invoked by the SILPrinter before the instruction \p I
    /// is written.
    mutating func printInstructionCallBack(_ I: UnsafePointer<swift.SILInstruction>!)
  }

  /// A descriptor for a public property or subscript that can be resiliently
  /// referenced from key paths in external modules.
  struct SILProperty {
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Serialized: Bool, _ Decl: UnsafeMutablePointer<swift.AbstractStorageDecl>!, _ Component: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift23KeyPathPatternComponentEEE) -> UnsafeMutablePointer<swift.SILProperty>!
    mutating func isSerialized() -> Bool
    mutating func getDecl() -> UnsafeMutablePointer<swift.AbstractStorageDecl>!
    mutating func isTrivial() -> Bool
    mutating func getComponent() -> UnsafePointer<llvm.__CxxTemplateInstN4llvm8OptionalIN5swift23KeyPathPatternComponentEEE>
    @warn_unqualified_access
    mutating func print(_ Ctx: UnsafeMutablePointer<swift.SILPrintContext>)
    mutating func dump()
    mutating func verify(_ M: UnsafePointer<swift.SILModule>)
  }

  /// Given an addressor, AddrF, return the global variable being addressed, or
  /// return nullptr if the addressor isn't a recognized pattern.
  static func getVariableOfGlobalInit(_ AddrF: UnsafeMutablePointer<swift.SILFunction>!) -> UnsafeMutablePointer<swift.SILGlobalVariable>!

  /// Return the callee of a once call.
  static func getCalleeOfOnceCall(_ BI: UnsafeMutablePointer<swift.BuiltinInst>!) -> UnsafeMutablePointer<swift.SILFunction>!

  /// Helper for getVariableOfGlobalInit(), so GlobalOpts can deeply inspect and
  /// rewrite the initialization pattern.
  ///
  /// Given an addressor, AddrF, find the call to the global initializer if
  /// present, otherwise return null. If an initializer is returned, then
  /// `CallToOnce` is initialized to the corresponding builtin "once" call.
  static func findInitializer(_ AddrF: UnsafeMutablePointer<swift.SILFunction>!, _ CallToOnce: UnsafeMutablePointer<UnsafeMutablePointer<swift.BuiltinInst>?>) -> UnsafeMutablePointer<swift.SILFunction>!

  /// Helper for getVariableOfGlobalInit(), so GlobalOpts can deeply inspect and
  /// rewrite the initialization pattern.
  ///
  /// Given a global initializer, InitFunc, return the GlobalVariable that it
  /// statically initializes or return nullptr if it isn't an obvious static
  /// initializer. If a global variable is returned, InitVal is initialized to the
  /// the instruction producing the global's initial value.
  static func getVariableOfStaticInitializer(_ InitFunc: UnsafeMutablePointer<swift.SILFunction>!, _ InitVal: UnsafeMutablePointer<UnsafeMutablePointer<swift.SingleValueInstruction>?>) -> UnsafeMutablePointer<swift.SILGlobalVariable>!

  /// VarDecl - 'var' and 'let' declarations.
  struct VarDecl {
    enum Introducer : UInt8 {
      init?(rawValue: UInt8)
      var rawValue: UInt8 { get }
      typealias RawValue = UInt8
      case Let
      case Var
    }
    init(_ isStatic: Bool, _ introducer: swift.VarDecl.Introducer, _ nameLoc: swift.SourceLoc, _ name: swift.Identifier, _ dc: UnsafeMutablePointer<swift.DeclContext>!)
    mutating func getSourceRange() -> swift.SourceRange
    mutating func getName() -> swift.Identifier

    /// Returns the string for the base name, or "_" if this is unnamed.
    mutating func getNameStr() -> llvm.StringRef

    /// Get the type of the variable within its context. If the context is generic,
    /// this will use archetypes.
    mutating func getType() -> swift.`Type`

    /// Retrieve the source range of the variable type, or an invalid range if the
    /// variable's type is not explicitly written in the source.
    ///
    /// Only for use in diagnostics.  It is not always possible to always
    /// precisely point to the variable type because of type aliases.
    mutating func getTypeSourceRangeForDiagnostics() -> swift.SourceRange

    /// Returns whether the var is settable in the specified context: this
    /// is either because it is a stored var, because it has a custom setter, or
    /// is a let member in an initializer.
    ///
    /// Pass a null context and null base to check if it's always settable.
    mutating func isSettable(_ UseDC: UnsafePointer<swift.DeclContext>!, _ base: OpaquePointer!) -> Bool

    /// Return the parent pattern binding that may provide an initializer for this
    /// VarDecl.  This returns null if there is none associated with the VarDecl.
    mutating func getParentPatternBinding() -> UnsafeMutablePointer<swift.PatternBindingDecl>!
    mutating func setParentPatternBinding(_ PBD: UnsafeMutablePointer<swift.PatternBindingDecl>!)

    /// Return the Pattern involved in initializing this VarDecl.  However, recall
    /// that the Pattern may be involved in initializing more than just this one
    /// vardecl.  For example, if this is a VarDecl for "x", the pattern may be
    /// "(x, y)" and the initializer on the PatternBindingDecl may be "(1,2)" or
    /// "foo()".
    ///
    /// If this has no parent pattern binding decl or statement associated, it
    /// returns null.
    ///
    mutating func getParentPattern() -> OpaquePointer!

    /// Returns the parsed type of this variable declaration.  For parameters, this
    /// is the parsed type the user explicitly wrote.  For variables, this is the
    /// type the user wrote in the typed pattern that binds this variable.
    ///
    /// Note that there are many cases where the user may elide types.  This will
    /// return null in those cases.
    mutating func getTypeReprOrParentPatternTypeRepr() -> OpaquePointer!

    /// Return the statement that owns the pattern associated with this VarDecl,
    /// if one exists.
    ///
    /// NOTE: After parsing and before type checking, all VarDecls from
    /// CaseLabelItem's Patterns return their CaseStmt. After type checking, we
    /// will have constructed the CaseLabelItem VarDecl linked list implying this
    /// will return nullptr. After type checking, if one wishes to find a parent
    /// pattern of a VarDecl of a CaseStmt, \see getRecursiveParentPatternStmt
    /// instead.
    mutating func getParentPatternStmt() -> OpaquePointer!
    mutating func setParentPatternStmt(_ s: OpaquePointer!)

    /// Look for the parent pattern stmt of this var decl, recursively
    /// looking through var decl pointers and then through any
    /// fallthroughts.
    mutating func getRecursiveParentPatternStmt() -> OpaquePointer!

    /// Returns the var decl that this var decl is an implicit reference to if
    /// such a var decl exists.
    mutating func getParentVarDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Set \p v to be the pattern produced VarDecl that is the parent of this
    /// var decl.
    mutating func setParentVarDecl(_ v: UnsafeMutablePointer<swift.VarDecl>!)
    mutating func getNamingPattern() -> OpaquePointer!
    mutating func setNamingPattern(_ Pat: OpaquePointer!)

    /// If this is a VarDecl that does not belong to a CaseLabelItem's pattern,
    /// return this. Otherwise, this VarDecl must belong to a CaseStmt's
    /// CaseLabelItem. In that case, return the first case label item of the first
    /// case stmt in a sequence of case stmts that fallthrough into each other.
    ///
    /// NOTE: During type checking, we emit an error if we have a single case
    /// label item with a pattern that has multiple var decls of the same
    /// name. This means that during type checking and before type checking, we
    /// may have a _malformed_ switch stmt var decl linked list since var decls in
    /// the same case label item that have the same name will point at the same
    /// canonical var decl, namely the first var decl with the name in the
    /// canonical case label item's var decl list. This is ok, since we are going
    /// to emit the error, but it requires us to be more careful/cautious before
    /// type checking has been complete when relying on canonical var decls
    /// matching up.
    mutating func getCanonicalVarDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// If this is a case stmt var decl, return the var decl that corresponds to
    /// this var decl in the first case label item of the case stmt. Returns
    /// nullptr if this isn't a VarDecl that is part of a case stmt.
    mutating func getCorrespondingFirstCaseLabelItemVarDecl() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE

    /// If this is a case stmt var decl, return the case body var decl that this
    /// var decl maps to.
    mutating func getCorrespondingCaseBodyVariable() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_7VarDeclEEE

    /// Return true if this var decl is an implicit var decl belonging to a case
    /// stmt's body.
    mutating func isCaseBodyVariable() -> Bool

    /// True if the global stored property requires lazy initialization.
    mutating func isLazilyInitializedGlobal() -> Bool

    /// Return the initializer involved in this VarDecl.  Recall that the
    /// initializer may be involved in initializing more than just this one
    /// vardecl though.  For example, if this is a VarDecl for "x", the pattern
    /// may be "(x, y)" and the initializer on the PatternBindingDecl may be
    /// "(1,2)" or "foo()".
    ///
    /// If this has no parent pattern binding decl associated, or if that pattern
    /// binding has no initial value, this returns null.
    ///
    mutating func getParentInitializer() -> OpaquePointer!

    /// Whether there exists an initializer for this \c VarDecl.
    mutating func isParentInitialized() -> Bool
    mutating func hasInitialValue() -> Bool
    mutating func getOverriddenDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Is this an immutable 'let' property?
    ///
    /// If this is a ParamDecl, isLet() is true iff
    /// getSpecifier() == Specifier::Default.
    mutating func isLet() -> Bool

    /// Is this an "async let" property?
    mutating func isAsyncLet() -> Bool
    mutating func getIntroducer() -> swift.VarDecl.Introducer
    mutating func setIntroducer(_ value: swift.VarDecl.Introducer)
    mutating func getParentCaptureList() -> OpaquePointer!

    /// Set \p v to be the pattern produced VarDecl that is the parent of this
    /// var decl.
    mutating func setParentCaptureList(_ expr: OpaquePointer!)

    /// Is this an element in a capture list?
    mutating func isCaptureList() -> Bool

    /// Is this a capture of the self param?
    mutating func isSelfParamCapture() -> Bool
    mutating func setIsSelfParamCapture(_ IsSelfParamCapture: Bool)

    /// Determines if this var has an initializer expression that should be
    /// exposed to clients.
    ///
    /// There's a very narrow case when we would: if the decl is an instance
    /// member with an initializer expression and the parent type is
    /// @frozen and resides in a resilient module.
    mutating func isInitExposedToClients() -> Bool

    /// Determines if this var is exposed as part of the layout of a
    /// @frozen struct.
    ///
    /// From the standpoint of access control and exportability checking, this
    /// var will behave as if it was public, even if it is internal or private.
    mutating func isLayoutExposedToClients() -> Bool

    /// Is this a special debugger variable?
    mutating func isDebuggerVar() -> Bool
    mutating func setDebuggerVar(_ IsDebuggerVar: Bool)

    /// Is this the synthesized storage for a 'lazy' property?
    mutating func isLazyStorageProperty() -> Bool
    mutating func setLazyStorageProperty(_ IsLazyStorage: Bool)

    /// True if this is a top-level global variable from the main source file.
    mutating func isTopLevelGlobal() -> Bool
    mutating func setTopLevelGlobal(_ b: Bool)

    /// Whether this property has any attached property wrappers.
    mutating func hasAttachedPropertyWrapper() -> Bool

    /// Whether all of the attached property wrappers have an init(wrappedValue:)
    /// initializer.
    mutating func allAttachedPropertyWrappersHaveWrappedValueInit() -> Bool

    /// Retrieve the type of the attached property wrapper as a contextual
    /// type.
    ///
    /// \param index Which property wrapper type is being computed, where 0
    /// indicates the first (outermost) attached property wrapper.
    ///
    /// \returns a NULL type for properties without attached wrappers,
    /// an error type when the property wrapper type itself is erroneous,
    /// or the wrapper type itself, which may involve unbound generic
    /// types.
    mutating func getAttachedPropertyWrapperType(_ index: UInt32) -> swift.`Type`

    /// Retrieve the fully resolved attached property wrapper type.
    ///
    /// This type will be the fully-resolved form of
    /// \c getAttachedPropertyWrapperType(0), which will not contain any
    /// unbound generic types. It will be the type of the backing property.
    mutating func getPropertyWrapperBackingPropertyType() -> swift.`Type`

    /// Retrieve information about the mutability of the composed
    /// property wrappers.
    mutating func getPropertyWrapperMutability() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift25PropertyWrapperMutabilityEEE

    /// Returns whether this property is the backing storage property or a storage
    /// wrapper for wrapper instance's projectedValue. If this property is
    /// neither, then it returns `None`.
    mutating func getPropertyWrapperSynthesizedPropertyKind() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift38PropertyWrapperSynthesizedPropertyKindEEE

    /// Retrieve the backing storage property for a property that has an
    /// attached property wrapper.
    ///
    /// The backing storage property will be a stored property of the
    /// wrapper's type. This will be equivalent to
    /// \c getAttachedPropertyWrapperType(0) when it is fully-specified;
    /// if \c getAttachedPropertyWrapperType(0) involves an unbound
    /// generic type, the backing storage property will be the appropriate
    /// bound generic version.
    mutating func getPropertyWrapperBackingProperty() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Retreive the projection var for a property that has an attached
    /// property wrapper with a \c projectedValue .
    mutating func getPropertyWrapperProjectionVar() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Retrieve the backing storage property for a lazy property.
    mutating func getLazyStorageProperty() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Whether the memberwise initializer parameter for a property with a
    /// property wrapper type uses the wrapped type. This will occur, for example,
    /// when there is an explicitly-specified initializer like:
    ///
    /// \code
    /// @Lazy var i = 17
    /// \endcode
    ///
    /// Or when there is no initializer but each composed property wrapper has
    /// a suitable `init(wrappedValue:)`.
    mutating func isPropertyMemberwiseInitializedWithWrappedType() -> Bool

    /// Return the interface type of the value used for the 'wrappedValue:'
    /// parameter when initializing a property wrapper.
    ///
    /// If the property has an attached property wrapper and the 'wrappedValue:'
    /// parameter is an autoclosure, return a function type returning the stored
    /// value. Otherwise, return the interface type of the stored value.
    mutating func getPropertyWrapperInitValueInterfaceType() -> swift.`Type`

    /// If this property is the backing storage for a property with an attached
    /// property wrapper, return the original property.
    ///
    /// \param kind If not \c None, only returns the original property when
    /// \c this property is the specified synthesized property.
    mutating func getOriginalWrappedProperty(_ kind: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift38PropertyWrapperSynthesizedPropertyKindEEE) -> UnsafeMutablePointer<swift.VarDecl>!

    /// Set the property that wraps to this property as it's backing
    /// property.
    mutating func setOriginalWrappedProperty(_ originalProperty: UnsafeMutablePointer<swift.VarDecl>!)

    /// Return the Objective-C runtime name for this property.
    mutating func getObjCPropertyName() -> swift.Identifier

    /// Retrieve the default Objective-C selector for the getter of a
    /// property of the given name.
    static func getDefaultObjCGetterSelector(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ propertyName: swift.Identifier) -> swift.ObjCSelector

    /// Retrieve the default Objective-C selector for the setter of a
    /// property of the given name.
    static func getDefaultObjCSetterSelector(_ ctx: UnsafeMutablePointer<swift.ASTContext>, _ propertyName: swift.Identifier) -> swift.ObjCSelector

    /// If this is a simple 'let' constant, emit a note with a fixit indicating
    /// that it can be rewritten to a 'var'.  This is used in situations where the
    /// compiler detects obvious attempts to mutate a constant.
    mutating func emitLetToVarNoteIfSimple(_ UseDC: UnsafeMutablePointer<swift.DeclContext>!)

    /// Returns true if the name is the self identifier and is implicit.
    mutating func isSelfParameter() -> Bool

    /// Determine whether this property will be part of the implicit memberwise
    /// initializer.
    ///
    /// \param preferDeclaredProperties When encountering a `lazy` property
    /// or a property that has an attached property wrapper, prefer the
    /// actual declared property (which may or may not be considered "stored"
    /// as the moment) to the backing storage property. Otherwise, the stored
    /// backing property will be treated as the member-initialized property.
    mutating func isMemberwiseInitialized(_ preferDeclaredProperties: Bool) -> Bool

    /// Return the range of semantics attributes attached to this VarDecl.
    mutating func getSemanticsAttrs() -> swift.__CxxTemplateInstN5swift22OptionalTransformRangeIN4llvm14iterator_rangeINS_14DeclAttributes14const_iteratorEEENS3_15ToAttributeKindINS_13SemanticsAttrELb0EEES4_EE

    /// Returns true if this VarDelc has the string \p attrValue as a semantics
    /// attribute.
    mutating func hasSemanticsAttr(_ attrValue: llvm.StringRef) -> Bool
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, F: UnsafePointer<swift.SILGlobalVariable>) -> UnsafeMutablePointer<llvm.raw_ostream>
  struct SILDifferentiabilityWitness {
    static func createDeclaration(_ module: UnsafeMutablePointer<swift.SILModule>, _ linkage: swift.SILLinkage, _ originalFunction: UnsafeMutablePointer<swift.SILFunction>!, _ parameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ resultIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ derivativeGenSig: swift.GenericSignature, _ attribute: UnsafePointer<swift.DeclAttribute>!) -> UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!
    static func createDefinition(_ module: UnsafeMutablePointer<swift.SILModule>, _ linkage: swift.SILLinkage, _ originalFunction: UnsafeMutablePointer<swift.SILFunction>!, _ parameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ resultIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ derivativeGenSig: swift.GenericSignature, _ jvp: UnsafeMutablePointer<swift.SILFunction>!, _ vjp: UnsafeMutablePointer<swift.SILFunction>!, _ isSerialized: Bool, _ attribute: UnsafePointer<swift.DeclAttribute>!) -> UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!
    mutating func convertToDefinition(_ jvp: UnsafeMutablePointer<swift.SILFunction>!, _ vjp: UnsafeMutablePointer<swift.SILFunction>!, _ isSerialized: Bool)
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getLinkage() -> swift.SILLinkage
    mutating func getOriginalFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getConfig() -> UnsafePointer<swift.AutoDiffConfig>
    mutating func getParameterIndices() -> UnsafeMutablePointer<swift.IndexSubset>!
    mutating func getResultIndices() -> UnsafeMutablePointer<swift.IndexSubset>!
    mutating func getDerivativeGenericSignature() -> swift.GenericSignature
    mutating func getJVP() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getVJP() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getDerivative(_ kind: swift.AutoDiffDerivativeFunctionKind) -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func setJVP(_ jvp: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func setVJP(_ vjp: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func setDerivative(_ kind: swift.AutoDiffDerivativeFunctionKind, _ derivative: UnsafeMutablePointer<swift.SILFunction>!)
    mutating func isDeclaration() -> Bool
    mutating func isDefinition() -> Bool
    mutating func isSerialized() -> Bool
    mutating func getAttribute() -> UnsafePointer<swift.DeclAttribute>!

    /// Verify that the differentiability witness is well-formed.
    mutating func verify(_ module: UnsafePointer<swift.SILModule>)
    mutating func print(_ os: UnsafeMutablePointer<llvm.raw_ostream>, _ verbose: Bool)
    mutating func dump()
  }

  /// ProtocolDecl - A declaration of a protocol, for example:
  ///
  ///   protocol Drawable {
  ///     func draw()
  ///   }
  ///
  /// Every protocol has an implicitly-created 'Self' generic parameter that
  /// stands for a type that conforms to the protocol. For example,
  ///
  ///   protocol Cloneable {
  ///     func clone() -> Self
  ///   }
  ///
  struct ProtocolDecl {
    init(_ DC: UnsafeMutablePointer<swift.DeclContext>!, _ ProtocolLoc: swift.SourceLoc, _ NameLoc: swift.SourceLoc, _ Name: swift.Identifier, _ Inherited: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7TypeLocEEE, _ TrailingWhere: OpaquePointer!)

    /// Retrieve the set of protocols inherited from this protocol.
    mutating func getInheritedProtocols() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIPN5swift12ProtocolDeclEEE

    /// Determine whether this protocol has a superclass.
    mutating func hasSuperclass() -> Bool

    /// Retrieve the superclass of this protocol, or null if there is no superclass.
    mutating func getSuperclass() -> swift.`Type`

    /// Retrieve the ClassDecl for the superclass of this protocol, or null if there
    /// is no superclass.
    mutating func getSuperclassDecl() -> UnsafeMutablePointer<swift.ClassDecl>!

    /// Set the superclass of this protocol.
    mutating func setSuperclass(_ superclass: swift.`Type`)

    /// Returns a protocol requirement with the given name, or nullptr if the
    /// name has multiple overloads, or no overloads at all.
    mutating func getSingleRequirement(_ name: swift.DeclName) -> UnsafeMutablePointer<swift.ValueDecl>!

    /// Returns an associated type with the given name, or nullptr if one does
    /// not exist.
    mutating func getAssociatedType(_ name: swift.Identifier) -> UnsafeMutablePointer<swift.AssociatedTypeDecl>!

    /// Determine whether this protocol inherits from the given ("super")
    /// protocol.
    mutating func inheritsFrom(_ Super: UnsafePointer<swift.ProtocolDecl>!) -> Bool
    mutating func getStartLoc() -> swift.SourceLoc
    mutating func getSourceRange() -> swift.SourceRange

    /// True if this protocol can only be conformed to by class types.
    mutating func requiresClass() -> Bool

    /// Determine whether an existential conforming to this protocol can be
    /// matched with a generic type parameter constrained to this protocol.
    /// This is only permitted if there is nothing "non-trivial" that we
    /// can do with the metatype, which means the protocol must not have
    /// any static methods and must be declared @objc.
    mutating func existentialConformsToSelf() -> Bool

    /// Does this protocol require a self-conformance witness table?
    mutating func requiresSelfConformanceWitnessTable() -> Bool

    /// Find direct Self references within the given requirement.
    ///
    /// \param treatNonResultCovariantSelfAsInvariant If true, 'Self' is only
    /// assumed to be covariant in a top-level non-function type, or in the
    /// eventual result type of a top-level function type.
    mutating func findProtocolSelfReferences(_ decl: UnsafePointer<swift.ValueDecl>!, _ treatNonResultCovariantSelfAsInvariant: Bool) -> swift.SelfReferenceInfo

    /// Determine whether we are allowed to refer to an existential type
    /// conforming to this protocol. This is only permitted if the type of
    /// the member does not contain any associated types, and does not
    /// contain 'Self' in 'parameter' or 'other' position.
    mutating func isAvailableInExistential(_ decl: UnsafePointer<swift.ValueDecl>!) -> Bool

    /// Determine whether we are allowed to refer to an existential type
    /// conforming to this protocol. This is only permitted if the types of
    /// all the members do not contain any associated types, and do not
    /// contain 'Self' in 'parameter' or 'other' position.
    mutating func existentialTypeSupported() -> Bool

    /// If this is known to be a compiler-known protocol, returns the kind.
    /// Otherwise returns None.
    mutating func getKnownProtocolKind() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift17KnownProtocolKindEEE

    /// Check whether this protocol is of a specific, known protocol kind.
    mutating func isSpecificProtocol(_ kind: swift.KnownProtocolKind) -> Bool

    /// Whether this protocol has a circular reference in its list of inherited
    /// protocols.
    mutating func hasCircularInheritedProtocols() -> Bool

    /// Returns true if the protocol has requirements that are not listed in its
    /// members.
    ///
    /// This can occur, for example, if the protocol is an Objective-C protocol
    /// with requirements that cannot be represented in Swift.
    mutating func hasMissingRequirements() -> Bool
    mutating func setHasMissingRequirements(_ newValue: Bool)

    /// Returns the default type witness for an associated type, or a null
    /// type if there is no default.
    mutating func getDefaultTypeWitness(_ assocType: UnsafeMutablePointer<swift.AssociatedTypeDecl>!) -> swift.`Type`

    /// Set the default type witness for an associated type.
    mutating func setDefaultTypeWitness(_ assocType: UnsafeMutablePointer<swift.AssociatedTypeDecl>!, _ witness: swift.`Type`)

    /// Returns the default witness for a requirement, or nullptr if there is
    /// no default.
    mutating func getDefaultWitness(_ requirement: UnsafeMutablePointer<swift.ValueDecl>!) -> swift.Witness

    /// Record the default witness for a requirement.
    mutating func setDefaultWitness(_ requirement: UnsafeMutablePointer<swift.ValueDecl>!, _ witness: swift.Witness)

    /// Returns the default associated conformance witness for an associated
    /// type, or \c None if there is no default.
    mutating func getDefaultAssociatedConformanceWitness(_ association: swift.CanType, _ requirement: UnsafeMutablePointer<swift.ProtocolDecl>!) -> swift.ProtocolConformanceRef

    /// Set the default associated conformance witness for the given
    /// associated conformance.
    mutating func setDefaultAssociatedConformanceWitness(_ association: swift.CanType, _ requirement: UnsafeMutablePointer<swift.ProtocolDecl>!, _ conformance: swift.ProtocolConformanceRef)

    /// Retrieve the name to use for this protocol when interoperating
    /// with the Objective-C runtime.
    mutating func getObjCRuntimeName(_ buffer: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIcEE>) -> llvm.StringRef

    /// Retrieve the requirements that describe this protocol.
    ///
    /// These are the requirements including any inherited protocols
    /// and conformances for associated types that are introduced in this
    /// protocol. Requirements implied via any other protocol (e.g., inherited
    /// protocols of the inherited protocols) are not mentioned. The conformance
    /// requirements listed here become entries in the witness table.
    mutating func getRequirementSignature() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift11RequirementEEE

    /// Is the requirement signature currently being computed?
    mutating func isComputingRequirementSignature() -> Bool

    /// Has the requirement signature been computed yet?
    mutating func isRequirementSignatureComputed() -> Bool
    mutating func setRequirementSignature(_ requirements: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift11RequirementEEE)
    mutating func setLazyRequirementSignature(_ lazyLoader: OpaquePointer!, _ requirementSignatureData: UInt64)
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.GenericTypeDecl>!) -> Bool
    static func classof(_ D: UnsafePointer<swift.NominalTypeDecl>!) -> Bool
    static func classof(_ C: UnsafePointer<swift.DeclContext>!) -> Bool
    static func classof(_ C: UnsafePointer<swift.IterableDeclContext>!) -> Bool
  }

  /// A mapping from each requirement of a protocol to the SIL-level entity
  /// satisfying the requirement for conformances which do not explicitly
  /// provide a witness.
  struct SILDefaultWitnessTable {

    /// A default witness table entry describing the default witness for a
    /// requirement.
    typealias Entry = swift.SILWitnessTable.Entry

    /// Create a new SILDefaultWitnessTable declaration.
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Linkage: swift.SILLinkage, _ Protocol: UnsafePointer<swift.ProtocolDecl>!) -> UnsafeMutablePointer<swift.SILDefaultWitnessTable>!

    /// Create a new SILDefaultWitnessTable definition with the given entries.
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Linkage: swift.SILLinkage, _ Protocol: UnsafePointer<swift.ProtocolDecl>!, _ entries: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE) -> UnsafeMutablePointer<swift.SILDefaultWitnessTable>!

    /// Get the linkage of the default witness table.
    mutating func getLinkage() -> swift.SILLinkage

    /// Set the linkage of the default witness table.
    mutating func setLinkage(_ l: swift.SILLinkage)
    mutating func convertToDefinition(_ entries: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE)

    /// Return true if this is a declaration with no body.
    mutating func isDeclaration() -> Bool

    /// Return the AST ProtocolDecl this default witness table is associated with.
    mutating func getProtocol() -> UnsafePointer<swift.ProtocolDecl>!

    /// Clears methods in witness entries.
    /// \p predicate Returns true if the passed entry should be set to null.
    mutating func clearMethods_if<Predicate>(_ predicate: Predicate)

    /// Return all of the default witness table entries.
    mutating func getEntries() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE

    /// Verify that the default witness table is well-formed.
    mutating func verify(_ M: UnsafePointer<swift.SILModule>)

    /// Print the default witness table.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool)

    /// Dump the default witness table to stderr.
    mutating func dump()
  }

  /// A mapping from each requirement of a protocol to the SIL-level entity
  /// satisfying the requirement for a concrete type.
  struct SILWitnessTable {

    /// A witness table entry describing the witness for a method.
    struct MethodWitness {

      /// The method required.
      var Requirement: swift.SILDeclRef

      /// The witness for the method.
      /// This can be null in case dead function elimination has removed the method.
      var Witness: UnsafeMutablePointer<swift.SILFunction>!
      init()
      init(Requirement: swift.SILDeclRef, Witness: UnsafeMutablePointer<swift.SILFunction>!)
    }

    /// A witness table entry describing the witness for an associated type.
    struct AssociatedTypeWitness {

      /// The associated type required.
      var Requirement: UnsafeMutablePointer<swift.AssociatedTypeDecl>!

      /// The concrete semantic type of the witness.
      var Witness: swift.CanType
      init()
      init(Requirement: UnsafeMutablePointer<swift.AssociatedTypeDecl>!, Witness: swift.CanType)
    }

    /// A witness table entry describing the witness for an associated type's
    /// protocol requirement.
    struct AssociatedTypeProtocolWitness {

      /// The associated type required.  A dependent type in the protocol's
      /// context.
      var Requirement: swift.CanType

      /// The protocol requirement on the type.
      var `Protocol`: UnsafeMutablePointer<swift.ProtocolDecl>!

      /// The ProtocolConformance satisfying the requirement. Null if the
      /// conformance is dependent.
      var Witness: swift.ProtocolConformanceRef
      init()
      init(Requirement: swift.CanType, Protocol: UnsafeMutablePointer<swift.ProtocolDecl>!, Witness: swift.ProtocolConformanceRef)
    }

    /// A witness table entry referencing the protocol conformance for a refined
    /// base protocol.
    struct BaseProtocolWitness {

      /// The base protocol.
      var Requirement: UnsafeMutablePointer<swift.ProtocolDecl>!

      /// The ProtocolConformance for the base protocol.
      var Witness: OpaquePointer!
      init()
      init(Requirement: UnsafeMutablePointer<swift.ProtocolDecl>!, Witness: OpaquePointer!)
    }

    /// A witness table entry kind.
    struct WitnessKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }

    /// A witness table entry.
    struct Entry {
      init()
      init(_ Method: UnsafePointer<swift.SILWitnessTable.MethodWitness>)
      init(_ AssociatedType: UnsafePointer<swift.SILWitnessTable.AssociatedTypeWitness>)
      init(_ AssociatedTypeProtocol: UnsafePointer<swift.SILWitnessTable.AssociatedTypeProtocolWitness>)
      init(_ BaseProtocol: UnsafePointer<swift.SILWitnessTable.BaseProtocolWitness>)
      mutating func getKind() -> swift.SILWitnessTable.WitnessKind
      mutating func isValid() -> Bool
      mutating func getMethodWitness() -> UnsafePointer<swift.SILWitnessTable.MethodWitness>
      mutating func getAssociatedTypeWitness() -> UnsafePointer<swift.SILWitnessTable.AssociatedTypeWitness>
      mutating func getAssociatedTypeProtocolWitness() -> UnsafePointer<swift.SILWitnessTable.AssociatedTypeProtocolWitness>
      mutating func getBaseProtocolWitness() -> UnsafePointer<swift.SILWitnessTable.BaseProtocolWitness>
      mutating func removeWitnessMethod()
      mutating func print(_ out: UnsafeMutablePointer<llvm.raw_ostream>, _ verbose: Bool, _ options: UnsafePointer<swift.PrintOptions>)
    }

    /// An entry for a conformance requirement that makes the requirement
    /// conditional. These aren't public, but any witness thunks need to feed them
    /// into the true witness functions.
    struct ConditionalConformance {
      var Requirement: swift.CanType
      var Conformance: swift.ProtocolConformanceRef
      init()
      init(Requirement: swift.CanType, Conformance: swift.ProtocolConformanceRef)
    }

    /// Create a new SILWitnessTable definition with the given entries.
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Linkage: swift.SILLinkage, _ Serialized: swift.IsSerialized_t, _ conformance: OpaquePointer!, _ entries: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE, _ conditionalConformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable22ConditionalConformanceEEE) -> UnsafeMutablePointer<swift.SILWitnessTable>!

    /// Create a new SILWitnessTable declaration.
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Linkage: swift.SILLinkage, _ conformance: OpaquePointer!) -> UnsafeMutablePointer<swift.SILWitnessTable>!

    /// Return the AST ProtocolConformance this witness table represents.
    mutating func getConformance() -> OpaquePointer!

    /// Return the context in which the conformance giving rise to this
    /// witness table was defined.
    mutating func getDeclContext() -> UnsafeMutablePointer<swift.DeclContext>!

    /// Return the protocol for which this witness table is a conformance.
    mutating func getProtocol() -> UnsafeMutablePointer<swift.ProtocolDecl>!

    /// Return the formal type which conforms to the protocol.
    ///
    /// Note that this will not be a substituted type: it may only be meaningful
    /// in the abstract context of the conformance rather than the context of any
    /// particular use of it.
    mutating func getConformingType() -> swift.CanType

    /// Return the symbol name of the witness table that will be propagated to the
    /// object file level.
    mutating func getName() -> llvm.StringRef

    /// Returns true if this witness table is a declaration.
    mutating func isDeclaration() -> Bool

    /// Returns true if this witness table is a definition.
    mutating func isDefinition() -> Bool

    /// Returns true if this witness table is going to be (or was) serialized.
    mutating func isSerialized() -> swift.IsSerialized_t

    /// Sets the serialized flag.
    mutating func setSerialized(_ serialized: swift.IsSerialized_t)

    /// Return all of the witness table entries.
    mutating func getEntries() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE

    /// Return all of the conditional conformances.
    mutating func getConditionalConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable22ConditionalConformanceEEE

    /// Clears methods in MethodWitness entries.
    /// \p predicate Returns true if the passed entry should be set to null.
    mutating func clearMethods_if<Predicate>(_ predicate: Predicate)

    /// Verify that the witness table is well-formed.
    mutating func verify(_ M: UnsafePointer<swift.SILModule>)

    /// Get the linkage of the witness table.
    mutating func getLinkage() -> swift.SILLinkage

    /// Set the linkage of the witness table.
    mutating func setLinkage(_ l: swift.SILLinkage)

    /// Change a SILWitnessTable declaration into a SILWitnessTable definition.
    mutating func convertToDefinition(_ newEntries: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable5EntryEEE, _ conditionalConformances: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift15SILWitnessTable22ConditionalConformanceEEE, _ isSerialized: swift.IsSerialized_t)
    static func conformanceIsSerialized(_ conformance: OpaquePointer!) -> Bool

    /// Print the witness table.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool)

    /// Dump the witness table to stderr.
    mutating func dump()
  }

  /// A mapping from source locations to expressions made up of profiling
  /// counters. This is used to embed information in build products for use with
  /// coverage tools later.
  struct SILCoverageMap {
    struct MappedRegion {
      var StartLine: UInt32
      var StartCol: UInt32
      var EndLine: UInt32
      var EndCol: UInt32
      var Counter: llvm.coverage.Counter
      init(_ StartLine: UInt32, _ StartCol: UInt32, _ EndLine: UInt32, _ EndCol: UInt32, _ Counter: llvm.coverage.Counter)
    }
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ Filename: llvm.StringRef, _ Name: llvm.StringRef, _ PGOFuncName: llvm.StringRef, _ Hash: UInt64, _ MappedRegions: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift14SILCoverageMap12MappedRegionEEE, _ Expressions: llvm.__CxxTemplateInstN4llvm8ArrayRefINS_8coverage17CounterExpressionEEE) -> UnsafeMutablePointer<swift.SILCoverageMap>!

    /// Return the name of the source file where this mapping is found.
    mutating func getFile() -> llvm.StringRef

    /// Return the mangled name of the function this mapping covers.
    mutating func getName() -> llvm.StringRef

    /// Return the name of this function as recorded in the profile symtab.
    mutating func getPGOFuncName() -> llvm.StringRef

    /// Return the coverage hash for function this mapping covers.
    mutating func getHash() -> UInt64

    /// Return all of the mapped regions.
    mutating func getMappedRegions() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift14SILCoverageMap12MappedRegionEEE

    /// Return all of the counter expressions.
    mutating func getExpressions() -> llvm.__CxxTemplateInstN4llvm8ArrayRefINS_8coverage17CounterExpressionEEE
    mutating func printCounter(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ C: llvm.coverage.Counter)

    /// Print the coverage map.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ Verbose: Bool, _ ShouldSort: Bool)
    @warn_unqualified_access
    mutating func print(_ PrintCtx: UnsafeMutablePointer<swift.SILPrintContext>)
    mutating func dump()
  }
  struct IsBare_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct IsTransparent_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct Inline_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct IsThunk_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct IsDynamicallyReplaceable_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct IsExactSelfClass_t : Equatable, RawRepresentable {
    init(_ rawValue: UInt32)
    init(rawValue: UInt32)
    var rawValue: UInt32
    typealias RawValue = UInt32
  }
  struct SILSpecializeAttr {
    enum SpecializationKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case Full
      case Partial
    }
    static func create(_ M: UnsafeMutablePointer<swift.SILModule>, _ specializedSignature: swift.GenericSignature, _ exported: Bool, _ kind: swift.SILSpecializeAttr.SpecializationKind, _ target: UnsafeMutablePointer<swift.SILFunction>!, _ spiGroup: swift.Identifier, _ spiModule: UnsafePointer<swift.ModuleDecl>!) -> UnsafeMutablePointer<swift.SILSpecializeAttr>!
    mutating func isExported() -> Bool
    mutating func isFullSpecialization() -> Bool
    mutating func isPartialSpecialization() -> Bool
    mutating func getSpecializationKind() -> swift.SILSpecializeAttr.SpecializationKind
    mutating func getSpecializedSignature() -> swift.GenericSignature
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getTargetFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getSPIGroup() -> swift.Identifier
    mutating func getSPIModule() -> UnsafePointer<swift.ModuleDecl>!
    @warn_unqualified_access
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, F: UnsafePointer<swift.SILFunction>) -> UnsafeMutablePointer<llvm.raw_ostream>
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, i: swift.SILPrintContext.ID) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Linkage for a SIL object.  This concept combines the notions
  /// of symbol linkage and visibility.
  ///
  /// Note that a Swift module is not the same thing as a SILModule.
  /// A SILModule is just a collection of objects.
  ///
  /// Semantic equivalence does not imply exact operational equivalence.
  /// For example, a function definition might be semantically
  /// equivalent to a second definition which uses a parameter that the
  /// first does not, perhaps by reading a value out of it (and then
  /// ignoring the result) or retaining it (and then releasing it
  /// later).
  enum SILLinkage : UInt8 {
    init?(rawValue: UInt8)
    var rawValue: UInt8 { get }
    typealias RawValue = UInt8

    /// This object definition is visible to multiple Swift modules (and
    /// thus potentially across linkage-unit boundaries).  There are no
    /// other object definitions with this name in the program.
    case Public

    /// This is a special linkage used for symbols which are treated
    /// as public for the purposes of SIL serialization and optimization,
    /// but do not have public entry points in the generated binary.
    ///
    /// There is no external variant of this linkage, because from other
    /// translation units in the same module, this behaves identically
    /// to the HiddenExternal linkage.
    ///
    /// When deserialized, such declarations receive Shared linkage.
    case PublicNonABI

    /// This object definition is visible only to the current Swift
    /// module (and thus should not be visible across linkage-unit
    /// boundaries).  There are no other object definitions with this
    /// name in the module.
    case Hidden

    /// This object definition is visible only within a single Swift
    /// module.  There may be other object definitions with this name in
    /// the module; those definitions are all guaranteed to be
    /// semantically equivalent to this one.
    case Shared

    /// This object definition is visible only within a single Swift
    /// file.
    case Private

    /// A Public definition with the same name as this object will be
    /// available to the current Swift module at runtime.  If this
    /// object is a definition, it is semantically equivalent to that
    /// definition.
    case PublicExternal

    /// A Public or Hidden definition with the same name as this object
    /// will be defined by the current Swift module at runtime.  If this
    /// object is a definition, it is semantically equivalent to that
    /// definition.
    case HiddenExternal

    /// This Shared definition was imported from another module. It is not
    /// necessary to serialize it since it can be deserialized from the original
    /// module. Besides that caveat this should be treated exactly the same as
    /// shared.
    case SharedExternal

    /// The same as SharedExternal, except that the definition is private in the
    /// other module. This can only occur if an inlined fragile function from
    /// another module references a private definition in the other module.
    case PrivateExternal

    /// The default linkage for a definition.
    static var DefaultForDefinition: swift.SILLinkage { get }

    /// The default linkage for an external declaration.
    static var DefaultForDeclaration: swift.SILLinkage { get }
  }

  /// The scope in which a subclassable class can be subclassed.
  enum SubclassScope : UInt8 {
    init?(rawValue: UInt8)
    var rawValue: UInt8 { get }
    typealias RawValue = UInt8

    /// This class can be subclassed in other modules.
    case External

    /// This class can only be subclassed in this module.
    case Internal

    /// This class is resilient so even public methods cannot be directly
    /// referenced from outside the module.
    case Resilient

    /// There is no class to subclass, or it is final.
    case NotApplicable
  }

  /// Strip external from public_external, hidden_external. Otherwise just return
  /// the linkage.
  static func stripExternalFromLinkage(_ linkage: swift.SILLinkage) -> swift.SILLinkage

  /// Add the 'external' attribute to \p linkage.
  static func addExternalToLinkage(_ linkage: swift.SILLinkage) -> swift.SILLinkage

  /// Return whether the linkage indicates that an object has a
  /// definition outside the current SILModule.
  static func isAvailableExternally(_ linkage: swift.SILLinkage) -> Bool

  /// Return whether the given linkage indicates that an object's
  /// definition might be required outside the current SILModule.
  /// If \p is true then we are in whole-module compilation.
  static func isPossiblyUsedExternally(_ linkage: swift.SILLinkage, _ wholeModule: Bool) -> Bool
  static func getDeclSILLinkage(_ decl: UnsafePointer<swift.ValueDecl>!) -> swift.SILLinkage
  static func hasPublicVisibility(_ linkage: swift.SILLinkage) -> Bool
  static func hasSharedVisibility(_ linkage: swift.SILLinkage) -> Bool
  static func hasPrivateVisibility(_ linkage: swift.SILLinkage) -> Bool
  static func effectiveLinkageForClassMember(_ linkage: swift.SILLinkage, _ scope: swift.SubclassScope) -> swift.SILLinkage
  static func fixmeWitnessHasLinkageThatNeedsToBePublic(_ witness: swift.SILDeclRef) -> Bool

  /// A SILLocation paired with a SILDebugScope.
  struct SILDebugLocation {
    init()
    init(_ location: swift.SILLocation, _ debugScope: UnsafePointer<swift.SILDebugScope>!)
    mutating func getLocation() -> swift.SILLocation
    mutating func getScope() -> UnsafePointer<swift.SILDebugScope>!
  }

  /// Determine whether an instruction may not have a SILDebugScope.
  static func maybeScopeless(_ I: UnsafeMutablePointer<swift.SILInstruction>) -> Bool

  /// Knows how to make a deep copy of a debug scope.
  struct ScopeCloner {

    /// ScopeCloner expects NewFn to be a clone of the original
    /// function, with all debug scopes and locations still pointing to
    /// the original function.
    init(_ NewFn: UnsafeMutablePointer<swift.SILFunction>)

    /// Return a (cached) deep copy of a scope.
    mutating func getOrCreateClonedScope(_ OrigScope: UnsafePointer<swift.SILDebugScope>!) -> UnsafePointer<swift.SILDebugScope>!
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, BB: UnsafePointer<swift.SILBasicBlock>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Abstract base class for allocation instructions, like alloc_stack, alloc_box
  /// and alloc_ref, etc.
  struct AllocationInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SingleValueInstruction>!) -> Bool

    /// Return the underlying variable declaration associated with this
    /// allocation, or null if this allocation inst is associated with a temporary
    /// allocation.
    mutating func getDecl() -> UnsafeMutablePointer<swift.VarDecl>!
  }

  /// An instruction which always produces a single value.
  ///
  /// Because this instruction is both a SILInstruction and a ValueBase,
  /// both of which inherit from SILNode, it introduces the need for
  /// some care when working with SILNodes.  See the comment on SILNode.
  struct SingleValueInstruction {
    init(_ kind: swift.SILInstructionKind, _ loc: swift.SILDebugLocation, _ type: swift.SILType)
    mutating func dump()
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getFunction() -> UnsafePointer<swift.SILFunction>!
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>
    mutating func getKind() -> swift.SILInstructionKind
    mutating func getValueKind() -> swift.ValueKind
    mutating func clone(_ insertPt: UnsafeMutablePointer<swift.SILInstruction>!) -> UnsafeMutablePointer<swift.SingleValueInstruction>!

    /// Override this to reflect the more efficient access pattern.
    mutating func getResults() -> swift.SILInstructionResultArray
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// An instruction that may produce an arbitrary number of values.
  struct MultipleValueInstruction {
    mutating func clone(_ insertPt: UnsafeMutablePointer<swift.SILInstruction>!) -> UnsafeMutablePointer<swift.MultipleValueInstruction>!
    mutating func getResult(_ Index: UInt32) -> swift.SILValue

    /// Return the index of \p Target if it is a result in the given
    /// MultipleValueInstructionResult. Otherwise, returns None.
    mutating func getIndexOfResult(_ Target: swift.SILValue) -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE
    mutating func getNumResults() -> UInt32
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// A value base result of a multiple value instruction.
  ///
  /// *NOTE* We want this to be a pure abstract class that does not add /any/ size
  /// to subclasses.
  struct MultipleValueInstructionResult {

    /// Create a new multiple value instruction result.
    ///
    /// \arg subclassDeltaOffset This is the delta offset in our parent object's
    /// layout in between the end of the MultipleValueInstruction object and the
    /// end of the specific subclass object.
    ///
    /// *NOTE* subclassDeltaOffset must be use only 5 bits. This gives us to
    /// support subclasses up to 32 bytes in size. We can scavange up to 6 more
    /// bits from ValueBase if this is not large enough.
    init(_ valueKind: swift.ValueKind, _ index: UInt32, _ type: swift.SILType, _ ownershipKind: swift.ValueOwnershipKind)

    /// Return the parent instruction of this result.
    mutating func getParent() -> UnsafeMutablePointer<swift.MultipleValueInstruction>!
    mutating func getParent() -> UnsafePointer<swift.MultipleValueInstruction>!
    mutating func getIndex() -> UInt32

    /// Get the ownership kind assigned to this result by its parent.
    ///
    /// This is stored in the bottom 3 bits of ValueBase's subclass data.
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind

    /// Set the ownership kind assigned to this result.
    ///
    /// This is stored in SILNode in the subclass data.
    mutating func setOwnershipKind(_ Kind: swift.ValueOwnershipKind)
    static func classof(_: UnsafePointer<swift.MultipleValueInstructionResult>!) -> Bool
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Instruction that takes in a tuple value and splits the tuple into the
  /// tuples's elements.
  struct DestructureTupleInst {
    static func create(_ F: UnsafePointer<swift.SILFunction>, _ Loc: swift.SILDebugLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestructureTupleInst>!
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Instruction that takes in a struct value and splits the struct into the
  /// struct's fields.
  struct DestructureStructInst {
    static func create(_ F: UnsafePointer<swift.SILFunction>, _ Loc: swift.SILDebugLocation, _ Operand: swift.SILValue) -> UnsafeMutablePointer<swift.DestructureStructInst>!
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// A subclass of SILInstruction which does not produce any values.
  struct NonValueInstruction {
    init(_ kind: swift.SILInstructionKind, _ loc: swift.SILDebugLocation)
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_: UnsafePointer<swift.NonValueInstruction>!) -> Bool
  }

  /// A formal SIL reference to a list of values, suitable for use as the result
  /// of a SILInstruction.
  ///
  /// *NOTE* Most multiple value instructions will not have many results, so if we
  /// want we can cache up to 3 bytes in the lower bits of the value.
  ///
  /// *NOTE* Most of this defined out of line further down in the file to work
  /// around forward declaration issues.
  ///
  /// *NOTE* The reason why this does not store the size of the stored element is
  /// that just from the number of elements we can infer the size of each element
  /// due to the restricted problem space. Specificially:
  ///
  /// 1. Size == 0 implies nothing is stored and thus element size is irrelevent.
  /// 2. Size == 1 implies we either had a single value instruction or a multiple
  /// value instruction, but no matter what instruction we had, we are going to
  /// store the results at the same starting location so element size is
  /// irrelevent.
  /// 3. Size > 1 implies we must be storing multiple value instruction results
  /// implying that the size of each stored element must be
  /// sizeof(MultipleValueInstructionResult).
  ///
  /// If we ever allow for subclasses of MultipleValueInstructionResult of
  /// different sizes, we will need to store a stride into
  /// SILInstructionResultArray. We always assume all results are the same
  /// subclass of MultipleValueInstructionResult.
  struct SILInstructionResultArray {
    typealias reverse_iterator = std.__1.__CxxTemplateInstNSt3__116reverse_iteratorIN5swift25SILInstructionResultArray8iteratorEEE
    typealias range = llvm.__CxxTemplateInstN4llvm14iterator_rangeIN5swift25SILInstructionResultArray8iteratorEEE
    typealias reverse_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINSt3__116reverse_iteratorIN5swift25SILInstructionResultArray8iteratorEEEEE
    typealias type_range = llvm.__CxxTemplateInstN4llvm14iterator_rangeINS_15mapped_iteratorIN5swift25SILInstructionResultArray8iteratorEPFNS2_7SILTypeENS2_8SILValueEES5_EEEE
    init()
    init(_ SVI: UnsafePointer<swift.SingleValueInstruction>!)
    init(_ results: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift30MultipleValueInstructionResultEEE)
    mutating func empty() -> Bool
    mutating func size() -> Int
    mutating func begin() -> swift.SILInstructionResultArray.iterator
    mutating func end() -> swift.SILInstructionResultArray.iterator
    mutating func rbegin() -> swift.SILInstructionResultArray.reverse_iterator
    mutating func rend() -> swift.SILInstructionResultArray.reverse_iterator
    mutating func getValues() -> swift.SILInstructionResultArray.range
    mutating func getReversedValues() -> swift.SILInstructionResultArray.reverse_range
    mutating func getTypes() -> swift.SILInstructionResultArray.type_range
    static func == (lhs: inout swift.SILInstructionResultArray, rhs: UnsafePointer<swift.SILInstructionResultArray>) -> Bool
    static func != (lhs: inout swift.SILInstructionResultArray, other: UnsafePointer<swift.SILInstructionResultArray>) -> Bool

    /// Returns true if both this and \p rhs have the same result types.
    ///
    /// *NOTE* This does not imply that the actual return SILValues are the
    /// same. Just that the types are the same.
    mutating func hasSameTypes(_ rhs: UnsafePointer<swift.SILInstructionResultArray>) -> Bool
  }

  /// SILType - A Swift type that has been lowered to a SIL representation type.
  /// In addition to the Swift type system, SIL adds "address" types that can
  /// reference any Swift type (but cannot take the address of an address). *T
  /// is the type of an address pointing at T.
  ///
  struct SILType {

    /// The unsigned is a SILValueCategory.
    typealias ValueType = llvm.__CxxTemplateInstN4llvm14PointerIntPairIPN5swift8TypeBaseELj2EjNS_21PointerLikeTypeTraitsIS3_EENS_18PointerIntPairInfoIS3_Lj2ES5_EEEE
    init()

    /// getPrimitiveType - Form a SILType for a primitive type that does not
    /// require any special handling (i.e., not a function or aggregate type).
    static func getPrimitiveType(_ T: swift.CanType, _ category: swift.SILValueCategory) -> swift.SILType

    /// Form the type of an r-value, given a Swift type that either does
    /// not require any special handling or has already been
    /// appropriately lowered.
    static func getPrimitiveObjectType(_ T: swift.CanType) -> swift.SILType

    /// Form the type for the address of an object, given a Swift type
    /// that either does not require any special handling or has already
    /// been appropriately lowered.
    static func getPrimitiveAddressType(_ T: swift.CanType) -> swift.SILType
    mutating func isNull() -> Bool
    mutating func getCategory() -> swift.SILValueCategory

    /// Returns the \p Category variant of this type.
    mutating func getCategoryType(_ Category: swift.SILValueCategory) -> swift.SILType

    /// Returns the variant of this type that matches \p Ty.getCategory()
    mutating func copyCategory(_ Ty: swift.SILType) -> swift.SILType

    /// Returns the address variant of this type.  Instructions which
    /// manipulate memory will generally work with object addresses.
    mutating func getAddressType() -> swift.SILType

    /// Returns the object variant of this type.  Note that address-only
    /// types are not legal to manipulate directly as objects in SIL.
    mutating func getObjectType() -> swift.SILType

    /// Returns the canonical AST type referenced by this SIL type.
    ///
    /// NOTE:
    /// 1. The returned AST type may not be a proper formal type.
    ///    For example, it may contain a SILFunctionType instead of a
    ///    FunctionType.
    /// 2. The returned type may not be the same as the original
    ///    unlowered type that produced this SILType (even after
    ///    canonicalization). If you need it, you must pass it separately.
    ///    For example, `AnyObject.Type` may get lowered to
    ///    `$@thick AnyObject.Type`, for which the AST type will be
    ///    `@thick AnyObject.Type`.
    ///    More generally, you cannot recover a formal type from
    ///    a lowered type. See docs/SIL.rst for more details.
    mutating func getASTType() -> swift.CanType
    @available(*, deprecated, message: "Please use getASTType()")
    mutating func getSwiftRValueType() -> swift.CanType

    /// Returns the AbstractCC of a function type.
    /// The SILType must refer to a function type.
    mutating func getFunctionRepresentation() -> swift.SILFunctionTypeRepresentation

    /// Returns true if the Swift type referenced by this SIL type is of the
    /// specified subtype.
    mutating func `is`<TYPE>() -> Bool
    mutating func isVoid() -> Bool

    /// Retrieve the ClassDecl for a type that maps to a Swift class or
    /// bound generic class type.
    mutating func getClassOrBoundGenericClass() -> UnsafeMutablePointer<swift.ClassDecl>!

    /// Retrieve the StructDecl for a type that maps to a Swift struct or
    /// bound generic struct type.
    mutating func getStructOrBoundGenericStruct() -> UnsafeMutablePointer<swift.StructDecl>!

    /// Retrieve the EnumDecl for a type that maps to a Swift enum or
    /// bound generic enum type.
    mutating func getEnumOrBoundGenericEnum() -> UnsafeMutablePointer<swift.EnumDecl>!

    /// Retrieve the NominalTypeDecl for a type that maps to a Swift
    /// nominal or bound generic nominal type.
    mutating func getNominalOrBoundGenericNominal() -> UnsafeMutablePointer<swift.NominalTypeDecl>!

    /// True if the type is an address type.
    mutating func isAddress() -> Bool

    /// True if the type is an object type.
    mutating func isObject() -> Bool

    /// isAddressOnly - True if the type, or the referenced type of an address
    /// type, is address-only.  For example, it could be a resilient struct or
    /// something of unknown size.
    ///
    /// This is equivalent to, but possibly faster than, calling
    /// tc.getTypeLowering(type).isAddressOnly().
    static func isAddressOnly(_ type: swift.CanType, _ tc: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ sig: swift.CanGenericSignature, _ expansion: swift.TypeExpansionContext) -> Bool

    /// Return true if this type must be returned indirectly.
    ///
    /// This is equivalent to, but possibly faster than, calling
    /// tc.getTypeLowering(type).isReturnedIndirectly().
    static func isFormallyReturnedIndirectly(_ type: swift.CanType, _ tc: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ sig: swift.CanGenericSignature) -> Bool

    /// Return true if this type must be passed indirectly.
    ///
    /// This is equivalent to, but possibly faster than, calling
    /// tc.getTypeLowering(type).isPassedIndirectly().
    static func isFormallyPassedIndirectly(_ type: swift.CanType, _ tc: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ sig: swift.CanGenericSignature) -> Bool

    /// True if the type, or the referenced type of an address type, is loadable.
    /// This is the opposite of isAddressOnly.
    mutating func isLoadable(_ F: UnsafePointer<swift.SILFunction>) -> Bool

    /// True if either:
    /// 1) The type, or the referenced type of an address type, is loadable.
    /// 2) The SIL Module conventions uses lowered addresses
    mutating func isLoadableOrOpaque(_ F: UnsafePointer<swift.SILFunction>) -> Bool

    /// True if the type, or the referenced type of an address type, is
    /// address-only. This is the opposite of isLoadable.
    mutating func isAddressOnly(_ F: UnsafePointer<swift.SILFunction>) -> Bool

    /// True if the underlying AST type is trivial, meaning it is loadable and can
    /// be trivially copied, moved or detroyed. Returns false for address types
    /// even though they are technically trivial.
    mutating func isTrivial(_ F: UnsafePointer<swift.SILFunction>) -> Bool

    /// True if the type, or the referenced type of an address type, is known to
    /// be a scalar reference-counted type such as a class, box, or thick function
    /// type. Returns false for non-trivial aggregates.
    mutating func isReferenceCounted(_ M: UnsafeMutablePointer<swift.SILModule>) -> Bool

    /// Returns true if the referenced type is a function type that never
    /// returns.
    mutating func isNoReturnFunction(_ M: UnsafeMutablePointer<swift.SILModule>, _ context: swift.TypeExpansionContext) -> Bool

    /// Returns true if the referenced AST type has reference semantics, even if
    /// the lowered SIL type is known to be trivial.
    mutating func hasReferenceSemantics() -> Bool

    /// Returns true if the referenced type is any sort of class-reference type,
    /// meaning anything with reference semantics that is not a function type.
    mutating func isAnyClassReferenceType() -> Bool

    /// Returns true if the referenced type is guaranteed to have a
    /// single-retainable-pointer representation.
    mutating func hasRetainablePointerRepresentation() -> Bool

    /// Returns true if the referenced type is an existential type.
    mutating func isExistentialType() -> Bool

    /// Returns true if the referenced type is any kind of existential type.
    mutating func isAnyExistentialType() -> Bool

    /// Returns true if the referenced type is a class existential type.
    mutating func isClassExistentialType() -> Bool

    /// Returns true if the referenced type is an opened existential type
    /// (which is actually a kind of archetype).
    mutating func isOpenedExistential() -> Bool

    /// Returns true if the referenced type is expressed in terms of one
    /// or more opened existential types.
    mutating func hasOpenedExistential() -> Bool

    /// Returns the representation used by an existential type. If the concrete
    /// type is provided, this may return a specialized representation kind that
    /// can be used for that type. Otherwise, returns the most general
    /// representation kind for the type. Returns None if the type is not an
    /// existential type.
    mutating func getPreferredExistentialRepresentation(_ containedType: swift.`Type`) -> swift.ExistentialRepresentation

    /// Returns true if the existential type can use operations for the given
    /// existential representation when working with values of the given type,
    /// or when working with an unknown type if containedType is null.
    mutating func canUseExistentialRepresentation(_ repr: swift.ExistentialRepresentation, _ containedType: swift.`Type`) -> Bool

    /// True if the type contains a type parameter.
    mutating func hasTypeParameter() -> Bool

    /// True if the type is bridgeable to an ObjC object pointer type.
    mutating func isBridgeableObjectType() -> Bool
    static func isClassOrClassMetatype(_ t: swift.`Type`) -> Bool

    /// True if the type is a class type or class metatype type.
    mutating func isClassOrClassMetatype() -> Bool

    /// True if the type involves any archetypes.
    mutating func hasArchetype() -> Bool

    /// True if the type involves any opaque archetypes.
    mutating func hasOpaqueArchetype() -> Bool

    /// Returns the ASTContext for the referenced Swift type.
    mutating func getASTContext() -> UnsafeMutablePointer<swift.ASTContext>

    /// True if the given type has at least the size and alignment of a native
    /// pointer.
    mutating func isPointerSizeAndAligned() -> Bool

    /// True if `operTy` can be cast by single-reference value into `resultTy`.
    static func canRefCast(_ operTy: swift.SILType, _ resultTy: swift.SILType, _ M: UnsafeMutablePointer<swift.SILModule>) -> Bool

    /// True if the type is block-pointer-compatible, meaning it either is a block
    /// or is an Optional with a block payload.
    mutating func isBlockPointerCompatible() -> Bool

    /// Given that this is a nominal type, return the lowered type of
    /// the given field.  Applies substitutions as necessary.  The
    /// result will be an address type if the base type is an address
    /// type or a class.
    mutating func getFieldType(_ field: UnsafeMutablePointer<swift.VarDecl>!, _ TC: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ context: swift.TypeExpansionContext) -> swift.SILType
    mutating func getFieldType(_ field: UnsafeMutablePointer<swift.VarDecl>!, _ M: UnsafeMutablePointer<swift.SILModule>, _ context: swift.TypeExpansionContext) -> swift.SILType

    /// Given that this is an enum type, return the lowered type of the
    /// data for the given element.  Applies substitutions as necessary.
    /// The result will have the same value category as the base type.
    mutating func getEnumElementType(_ elt: UnsafeMutablePointer<swift.EnumElementDecl>!, _ TC: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ context: swift.TypeExpansionContext) -> swift.SILType
    mutating func getEnumElementType(_ elt: UnsafeMutablePointer<swift.EnumElementDecl>!, _ M: UnsafeMutablePointer<swift.SILModule>, _ context: swift.TypeExpansionContext) -> swift.SILType

    /// Given that this is an enum type, return true if this type is effectively
    /// exhausted.
    mutating func isEffectivelyExhaustiveEnumType(_ f: UnsafeMutablePointer<swift.SILFunction>!) -> Bool

    /// Given that this is a tuple type, return the lowered type of the
    /// given tuple element.  The result will have the same value
    /// category as the base type.
    mutating func getTupleElementType(_ index: UInt32) -> swift.SILType

    /// Return the immediate superclass type of this type, or null if
    /// it's the most-derived type.
    mutating func getSuperclass() -> swift.SILType

    /// Return true if Ty is a subtype of this exact SILType, or false otherwise.
    mutating func isExactSuperclassOf(_ Ty: swift.SILType) -> Bool

    /// Return true if Ty is a subtype of this SILType, or if this SILType
    /// contains archetypes that can be found to form a supertype of Ty, or false
    /// otherwise.
    mutating func isBindableToSuperclassOf(_ Ty: swift.SILType) -> Bool

    /// Look through reference-storage types on this type.
    mutating func getReferenceStorageReferentType() -> swift.SILType

    /// Return the reference ownership of this type if it is a reference storage
    /// type. Otherwse, return None.
    mutating func getReferenceStorageOwnership() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift18ReferenceOwnershipEEE

    /// Attempt to wrap the passed in type as a type with reference ownership \p
    /// ownership. For simplicity, we always return an address since reference
    /// storage types may not be loadable (e.x.: weak ownership).
    mutating func getReferenceStorageType(_ ctx: UnsafePointer<swift.ASTContext>, _ ownership: swift.ReferenceOwnership) -> swift.SILType

    /// Transform the function type SILType by replacing all of its interface
    /// generic args with the appropriate item from the substitution.
    ///
    /// Only call this with function types!
    mutating func substGenericArgs(_ TC: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ SubMap: swift.SubstitutionMap, _ context: swift.TypeExpansionContext) -> swift.SILType
    mutating func substGenericArgs(_ M: UnsafeMutablePointer<swift.SILModule>, _ SubMap: swift.SubstitutionMap, _ context: swift.TypeExpansionContext) -> swift.SILType

    /// If the original type is generic, pass the signature as genericSig.
    ///
    /// If the replacement types are generic, you must push a generic context
    /// first.
    mutating func subst(_ tc: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ subs: swift.TypeSubstitutionFn, _ conformances: swift.LookupConformanceFn, _ genericSig: swift.CanGenericSignature, _ shouldSubstituteOpaqueArchetypes: Bool) -> swift.SILType
    mutating func subst(_ M: UnsafeMutablePointer<swift.SILModule>, _ subs: swift.TypeSubstitutionFn, _ conformances: swift.LookupConformanceFn, _ genericSig: swift.CanGenericSignature, _ shouldSubstituteOpaqueArchetypes: Bool) -> swift.SILType
    mutating func subst(_ tc: UnsafeMutablePointer<swift.Lowering.TypeConverter>, _ subs: swift.SubstitutionMap) -> swift.SILType
    mutating func subst(_ M: UnsafeMutablePointer<swift.SILModule>, _ subs: swift.SubstitutionMap) -> swift.SILType
    mutating func subst(_ M: UnsafeMutablePointer<swift.SILModule>, _ subs: swift.SubstitutionMap, _ context: swift.TypeExpansionContext) -> swift.SILType

    /// Return true if this type references a "ref" type that has a single pointer
    /// representation. Class existentials do not always qualify.
    mutating func isHeapObjectReferenceType() -> Bool

    /// Returns true if this SILType is an aggregate that contains \p Ty
    mutating func aggregateContainsRecord(_ Ty: swift.SILType, _ SILMod: UnsafeMutablePointer<swift.SILModule>, _ context: swift.TypeExpansionContext) -> Bool

    /// Returns true if this SILType is an aggregate with unreferenceable storage,
    /// meaning it cannot be fully destructured in SIL.
    mutating func aggregateHasUnreferenceableStorage() -> Bool

    /// Returns the lowered type for T if this type is Optional<T>;
    /// otherwise, return the null type.
    mutating func getOptionalObjectType() -> swift.SILType

    /// Unwraps one level of optional type.
    /// Returns the lowered T if the given type is Optional<T>.
    /// Otherwise directly returns the given type.
    mutating func unwrapOptionalType() -> swift.SILType

    /// Returns true if this is the AnyObject SILType;
    mutating func isAnyObject() -> Bool

    /// Returns a SILType with any archetypes mapped out of context.
    mutating func mapTypeOutOfContext() -> swift.SILType

    /// Given a lowered type (but without any particular value category),
    /// map it out of its current context.  Equivalent to
    /// SILType::getPrimitiveObjectType(type).mapTypeOutOfContext().getASTType().
    static func mapTypeOutOfContext(_ type: swift.CanType) -> swift.CanType

    /// Given two SIL types which are representations of the same type,
    /// check whether they have an abstraction difference.
    mutating func hasAbstractionDifference(_ rep: swift.SILFunctionTypeRepresentation, _ type2: swift.SILType) -> Bool

    /// Returns true if this SILType could be potentially a lowering of the given
    /// formal type. Meant for verification purposes/assertions.
    mutating func isLoweringOf(_ context: swift.TypeExpansionContext, _ M: UnsafeMutablePointer<swift.SILModule>, _ formalType: swift.CanType) -> Bool

    /// Returns true if this SILType is a differentiable type.
    mutating func isDifferentiable(_ M: UnsafeMutablePointer<swift.SILModule>) -> Bool

    /// Returns the hash code for the SILType.
    mutating func getHashCode() -> llvm.hash_code

    /// Get the NativeObject type as a SILType.
    static func getNativeObjectType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get the BridgeObject type as a SILType.
    static func getBridgeObjectType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get the RawPointer type as a SILType.
    static func getRawPointerType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get a builtin integer type as a SILType.
    static func getBuiltinIntegerType(_ bitWidth: UInt32, _ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get the IntegerLiteral type as a SILType.
    static func getBuiltinIntegerLiteralType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get a builtin floating-point type as a SILType.
    static func getBuiltinFloatType(_ Kind: swift.BuiltinFloatType.FPKind, _ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get the builtin word type as a SILType;
    static func getBuiltinWordType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Given a value type, return an optional type wrapping it.
    static func getOptionalType(_ valueType: swift.SILType) -> swift.SILType

    /// Get the standard exception type.
    static func getExceptionType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType

    /// Get the SIL token type.
    static func getSILTokenType(_ C: UnsafePointer<swift.ASTContext>) -> swift.SILType
    static func getFromOpaqueValue(_ P: UnsafeMutableRawPointer!) -> swift.SILType
    mutating func getOpaqueValue() -> UnsafeMutableRawPointer!
    static func == (lhs: inout swift.SILType, rhs: swift.SILType) -> Bool
    static func != (lhs: inout swift.SILType, rhs: swift.SILType) -> Bool
    mutating func dump()
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ PO: UnsafePointer<swift.PrintOptions>)
  }
  struct FunctionRefBaseInst {

    /// Return the referenced function if this is a function_ref instruction and
    /// therefore a client can rely on the dynamically called function being equal
    /// to the returned value and null otherwise.
    mutating func getReferencedFunctionOrNull() -> UnsafeMutablePointer<swift.SILFunction>!

    /// Return the initially referenced function.
    ///
    /// WARNING: This not necessarily the function that will be called at runtime.
    /// If the callee is a (prev_)dynamic_function_ref the actual function called
    /// might be different because it could be dynamically replaced at runtime.
    ///
    /// If the client of this API wants to look at the content of the returned SIL
    /// function it should call getReferencedFunctionOrNull() instead.
    mutating func getInitiallyReferencedFunction() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func dropReferencedFunction()
    mutating func getConventions() -> swift.SILFunctionConventions
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ node: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  enum SILInstructionKind : std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type {
    init?(rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type)
    var rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type { get }
    typealias RawValue = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type
    case AllocStackInst
    case AllocRefInst
    case AllocRefDynamicInst
    case AllocValueBufferInst
    case AllocBoxInst
    case AllocExistentialBoxInst
    static var First_AllocationInst: swift.SILInstructionKind { get }
    static var Last_AllocationInst: swift.SILInstructionKind { get }
    case IndexAddrInst
    case TailAddrInst
    case IndexRawPointerInst
    static var First_IndexingInst: swift.SILInstructionKind { get }
    static var Last_IndexingInst: swift.SILInstructionKind { get }
    case FunctionRefInst
    case DynamicFunctionRefInst
    case PreviousDynamicFunctionRefInst
    case GlobalAddrInst
    case BaseAddrForOffsetInst
    case GlobalValueInst
    case IntegerLiteralInst
    case FloatLiteralInst
    case StringLiteralInst
    static var First_LiteralInst: swift.SILInstructionKind { get }
    static var Last_LiteralInst: swift.SILInstructionKind { get }
    case ClassMethodInst
    case SuperMethodInst
    case ObjCMethodInst
    case ObjCSuperMethodInst
    case WitnessMethodInst
    static var First_MethodInst: swift.SILInstructionKind { get }
    static var Last_MethodInst: swift.SILInstructionKind { get }
    case UpcastInst
    case AddressToPointerInst
    case PointerToAddressInst
    case UncheckedRefCastInst
    case UncheckedAddrCastInst
    case UncheckedTrivialBitCastInst
    case UncheckedBitwiseCastInst
    case UncheckedValueCastInst
    case RefToRawPointerInst
    case RawPointerToRefInst
    case RefToUnownedInst
    case UnownedToRefInst
    case RefToUnmanagedInst
    case UnmanagedToRefInst
    case ConvertFunctionInst
    case ConvertEscapeToNoEscapeInst
    case ThinFunctionToPointerInst
    case PointerToThinFunctionInst
    case RefToBridgeObjectInst
    case BridgeObjectToRefInst
    case BridgeObjectToWordInst
    case ThinToThickFunctionInst
    case ThickToObjCMetatypeInst
    case ObjCToThickMetatypeInst
    case ObjCMetatypeToObjectInst
    case ObjCExistentialMetatypeToObjectInst
    case UnconditionalCheckedCastValueInst
    case UnconditionalCheckedCastInst
    static var First_ConversionInst: swift.SILInstructionKind { get }
    static var Last_ConversionInst: swift.SILInstructionKind { get }
    case ClassifyBridgeObjectInst
    case ValueToBridgeObjectInst
    case MarkDependenceInst
    case CopyBlockInst
    case CopyBlockWithoutEscapingInst
    case CopyValueInst
    case StrongCopyUnownedValueInst
    case StrongCopyUnmanagedValueInst
    case UncheckedOwnershipConversionInst
    case IsUniqueInst
    case EndCOWMutationInst
    case IsEscapingClosureInst
    case LoadInst
    case LoadBorrowInst
    case BeginBorrowInst
    case StoreBorrowInst
    case BeginAccessInst
    case LoadWeakInst
    case LoadUnownedInst
    case MarkUninitializedInst
    case ProjectValueBufferInst
    case ProjectBoxInst
    case ProjectExistentialBoxInst
    case ApplyInst
    case BuiltinInst
    case PartialApplyInst
    case MetatypeInst
    case ValueMetatypeInst
    case ExistentialMetatypeInst
    case ObjCProtocolInst
    case ObjectInst
    case TupleInst
    case TupleExtractInst
    case TupleElementAddrInst
    case StructInst
    case StructExtractInst
    case StructElementAddrInst
    case RefElementAddrInst
    case RefTailAddrInst
    case EnumInst
    case UncheckedEnumDataInst
    case InitEnumDataAddrInst
    case UncheckedTakeEnumDataAddrInst
    case SelectEnumInst
    case SelectEnumAddrInst
    case SelectValueInst
    case InitExistentialAddrInst
    case InitExistentialValueInst
    case OpenExistentialAddrInst
    case InitExistentialRefInst
    case OpenExistentialRefInst
    case InitExistentialMetatypeInst
    case OpenExistentialMetatypeInst
    case OpenExistentialBoxInst
    case OpenExistentialValueInst
    case OpenExistentialBoxValueInst
    case ProjectBlockStorageInst
    case InitBlockStorageHeaderInst
    case DifferentiableFunctionInst
    case LinearFunctionInst
    case DifferentiableFunctionExtractInst
    case LinearFunctionExtractInst
    case DifferentiabilityWitnessFunctionInst
    case GetAsyncContinuationInst
    case GetAsyncContinuationAddrInst
    static var First_GetAsyncContinuationInstBase: swift.SILInstructionKind { get }
    static var Last_GetAsyncContinuationInstBase: swift.SILInstructionKind { get }
    case KeyPathInst
    static var First_SingleValueInstruction: swift.SILInstructionKind { get }
    static var Last_SingleValueInstruction: swift.SILInstructionKind { get }
    case UnreachableInst
    case ReturnInst
    case ThrowInst
    case YieldInst
    case UnwindInst
    case TryApplyInst
    case BranchInst
    case CondBranchInst
    case SwitchValueInst
    case SwitchEnumInst
    case SwitchEnumAddrInst
    case DynamicMethodBranchInst
    case AwaitAsyncContinuationInst
    case CheckedCastBranchInst
    case CheckedCastAddrBranchInst
    case CheckedCastValueBranchInst
    static var First_TermInst: swift.SILInstructionKind { get }
    static var Last_TermInst: swift.SILInstructionKind { get }
    case DeallocStackInst
    case DeallocRefInst
    case DeallocPartialRefInst
    case DeallocValueBufferInst
    case DeallocBoxInst
    case DeallocExistentialBoxInst
    static var First_DeallocationInst: swift.SILInstructionKind { get }
    static var Last_DeallocationInst: swift.SILInstructionKind { get }
    case StrongRetainInst
    case StrongReleaseInst
    case UnmanagedRetainValueInst
    case UnmanagedReleaseValueInst
    case UnmanagedAutoreleaseValueInst
    case StrongRetainUnownedInst
    case UnownedRetainInst
    case UnownedReleaseInst
    case RetainValueInst
    case RetainValueAddrInst
    case ReleaseValueInst
    case ReleaseValueAddrInst
    case SetDeallocatingInst
    case AutoreleaseValueInst
    static var First_RefCountingInst: swift.SILInstructionKind { get }
    static var Last_RefCountingInst: swift.SILInstructionKind { get }
    case BindMemoryInst
    case FixLifetimeInst
    case HopToExecutorInst
    case DestroyValueInst
    case EndBorrowInst
    case EndAccessInst
    case BeginUnpairedAccessInst
    case EndUnpairedAccessInst
    case StoreInst
    case AssignInst
    case AssignByWrapperInst
    case MarkFunctionEscapeInst
    case DebugValueInst
    case DebugValueAddrInst
    case StoreWeakInst
    case StoreUnownedInst
    case CopyAddrInst
    case DestroyAddrInst
    case EndLifetimeInst
    case InjectEnumAddrInst
    case DeinitExistentialAddrInst
    case DeinitExistentialValueInst
    case UnconditionalCheckedCastAddrInst
    case UncheckedRefCastAddrInst
    case AllocGlobalInst
    case EndApplyInst
    case AbortApplyInst
    case CondFailInst
    case BeginApplyInst
    case BeginCOWMutationInst
    case DestructureStructInst
    case DestructureTupleInst
    static var First_MultipleValueInstruction: swift.SILInstructionKind { get }
    static var Last_MultipleValueInstruction: swift.SILInstructionKind { get }
  }

  /// Return a range which can be used to easily iterate over all
  /// SILInstructionKinds.
  static func allSILInstructionKinds() -> swift.__CxxTemplateInstN5swift8IntRangeINS_18SILInstructionKindENS_14IntRangeTraitsIS1_Lb1EEEEE

  /// Map SILInstruction's mnemonic name to its SILInstructionKind.
  static func getSILInstructionKind(_ InstName: llvm.StringRef) -> swift.SILInstructionKind

  /// Map SILInstructionKind to a corresponding SILInstruction name.
  static func getSILInstructionName(_ Kind: swift.SILInstructionKind) -> llvm.StringRef
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, I: UnsafePointer<swift.SILInstruction>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Returns the combined behavior of \p B1 and \p B2.
  static func combineMemoryBehavior(_ B1: swift.SILInstruction.MemoryBehavior, _ B2: swift.SILInstruction.MemoryBehavior) -> swift.SILInstruction.MemoryBehavior

  /// Pretty-print the MemoryBehavior.
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, B: swift.SILInstruction.MemoryBehavior) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Pretty-print the ReleasingBehavior.
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, B: swift.SILInstruction.ReleasingBehavior) -> UnsafeMutablePointer<llvm.raw_ostream>
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, I: UnsafePointer<swift.SingleValueInstruction>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Abstract base class used for isa checks on instructions to determine if they
  /// forward ownership and to verify that the set of ownership instructions and
  /// the ownership utilities stay in sync via assertions.
  ///
  /// NOTE: We assume that the constructor for the instruction subclass that
  /// initializes the kind field on our object is run before our constructor runs.
  struct OwnershipForwardingInst {
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind
    mutating func setOwnershipKind(_ newKind: swift.ValueOwnershipKind)
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool

    /// Define inline below due to forward declaration issues.
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
  }

  /// A single value inst that forwards a static ownership from one (or all) of
  /// its operands.
  ///
  /// The ownership kind is set on construction and afterwards must be changed
  /// explicitly using setOwnershipKind().
  struct FirstArgOwnershipForwardingSingleValueInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
  }

  /// An ownership forwarding single value that has a preferred operand of owned
  /// but if its inputs are all none can have OwnershipKind::None as a result. We
  /// assume that we always forward from operand 0.
  struct OwnedFirstArgForwardingSingleValueInst {
    mutating func getPreferredOwnership() -> swift.ValueOwnershipKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
  }

  /// An instruction that forwards guaranteed or none ownership. Assumed to always
  /// forward from Operand(0) -> Result(0).
  struct GuaranteedFirstArgForwardingSingleValueInst {
    mutating func getPreferredOwnership() -> swift.ValueOwnershipKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
  }
  struct AllArgOwnershipForwardingSingleValueInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE82ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE7ENS_14AllocationInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE8ENS_16AllocRefInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE9ENS_16AllocRefInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE10ENS_14AllocationInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE11ENS_14AllocationInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE12ENS_14AllocationInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE81ENS_13ApplyInstBaseINS_9ApplyInstENS_22SingleValueInstructionELb1EEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE83ENS_13ApplyInstBaseINS_16PartialApplyInstENS_22SingleValueInstructionELb0EEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE188ENS_13ApplyInstBaseINS_14BeginApplyInstENS_24MultipleValueInstructionELb1EEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE186ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE185ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE121ENS_28GetAsyncContinuationInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE122ENS_28GetAsyncContinuationInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE162ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE123ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE184ENS_14SILInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE19ENS_16GlobalAccessInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE20ENS_11LiteralInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE21ENS_16GlobalAccessInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE22ENS_11LiteralInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE23ENS_11LiteralInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE24ENS_11LiteralInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE70ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE168ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE71ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE72ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE73ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE164ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE74ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE165ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE166ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE167ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE169ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE170ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE77ENS_38OwnedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE171ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE172ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE173ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE75ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE76ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE174ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE175ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE176ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE160ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE44ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE45ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE46ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE47ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE30ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE31ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE32ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE33ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE35ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE36ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE37ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE48ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE58ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE49ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE59ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE50ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE38ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE39ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE40ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE41ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE42ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE43ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE51ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE52ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE53ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE54ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE55ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE87ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE57ENS_33OwnershipForwardingConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE56ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE92ENS_40AllArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE154ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE155ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE156ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE157ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE148ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE149ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE150ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE159ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE158ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE88ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE89ENS_40AllArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE97ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE98ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE99ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE179ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE100ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE101ENS_37OwnershipForwardingSelectEnumInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE102ENS_18SelectEnumInstBaseELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE103ENS_14SelectInstBaseINS_15SelectValueInstENS_8SILValueENS_42FirstArgOwnershipForwardingSingleValueInstEEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE84ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE85ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE86ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE90ENS_43GuaranteedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE91ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE93ENS_19FieldIndexCacheBaseINS_43GuaranteedFirstArgForwardingSingleValueInstEEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE94ENS_19FieldIndexCacheBaseINS_22SingleValueInstructionEEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE95ENS_19FieldIndexCacheBaseINS_22SingleValueInstructionEEELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE96ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE25ENS_10MethodInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE26ENS_10MethodInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE27ENS_10MethodInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE28ENS_10MethodInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE29ENS_10MethodInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE106ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE112ENS_43GuaranteedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE108ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE110ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE111ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE113ENS_43GuaranteedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE104ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE105ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE107ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE109ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE180ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE181ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE114ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE115ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE146ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE147ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE151ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE152ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE153ENS_15RefCountingInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE161ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE178ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE66ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE60ENS_42FirstArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE61ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE62ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE63ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE64ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE65ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE163ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE67ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE189ENS_24MultipleValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE68ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE69ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE140ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE141ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE142ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE143ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE144ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE145ENS_16DeallocationInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE177ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE78ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE79ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE80ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE187ENS_19NonValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE13ENS_12IndexingInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE14ENS_12IndexingInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE15ENS_12IndexingInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE124ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE125ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE126ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE128ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE136ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE127ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE130ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE131ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE132ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE133ENS_18SwitchEnumInstBaseINS_27OwnershipForwardingTermInstEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE134ENS_18SwitchEnumInstBaseINS_8TermInstEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE135ENS_8TermInstELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE137ENS_18CastBranchInstBaseINS_27OwnershipForwardingTermInstEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE139ENS_18CastBranchInstBaseINS_8TermInstEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE138ENS_17TypesForAddrCastsINS_33CastBranchWithConsumptionKindBaseEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE183ENS_17TypesForAddrCastsINS_19NonValueInstructionEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE34ENS_14ConversionInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE182ENS_17TypesForAddrCastsINS_19NonValueInstructionEEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE129ENS_13ApplyInstBaseINS_12TryApplyInstENS_16TryApplyInstBaseELb1EEELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE116ENS_40AllArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE117ENS_40AllArgOwnershipForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE118ENS_43GuaranteedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE119ENS_43GuaranteedFirstArgForwardingSingleValueInstELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE120ENS_22SingleValueInstructionELb1EEE {

    /// Override to statically return the kind.
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ I: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE190ENS_43OwnershipForwardingMultipleValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  struct __CxxTemplateInstN5swift15InstructionBaseILNS_18SILInstructionKindE191ENS_43OwnershipForwardingMultipleValueInstructionELb0EEE {
    static func getKind() -> swift.SILInstructionKind
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE90ENS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE186ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE185ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE122ENS_28GetAsyncContinuationInstBaseEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE162ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE70ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE71ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE72ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE164ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE74ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE165ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE167ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE77ENS_38OwnedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE172ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE173ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE75ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE76ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE46ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE31ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE32ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE58ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE49ENS_33OwnershipForwardingConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE59ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE50ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE38ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE39ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE40ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE41ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE42ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE43ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE52ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE53ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE54ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE55ENS_14ConversionInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE154ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE155ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE156ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE157ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE148ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE149ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE150ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE159ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE158ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE98ENS_42FirstArgOwnershipForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE99ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE179ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE100ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE85ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE86ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE91ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE93ENS_19FieldIndexCacheBaseINS_43GuaranteedFirstArgForwardingSingleValueInstEEEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE94ENS_19FieldIndexCacheBaseINS_22SingleValueInstructionEEEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE95ENS_19FieldIndexCacheBaseINS_22SingleValueInstructionEEEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE96ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE25ENS_10MethodInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE26ENS_10MethodInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE28ENS_10MethodInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE106ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE112ENS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE108ENS_42FirstArgOwnershipForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE110ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE111ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE113ENS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE180ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE181ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE114ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE146ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE147ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE151ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE152ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE153ENS_15RefCountingInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE161ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE178ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE66ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE61ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE63ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE64ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE65ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE163ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE67ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE189ENS_24MultipleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE68ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE69ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE140ENS_16DeallocationInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE141ENS_16DeallocationInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE143ENS_16DeallocationInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE144ENS_16DeallocationInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE145ENS_16DeallocationInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE177ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE78ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE79ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE80ENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE187ENS_19NonValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE125ENS_8TermInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE126ENS_8TermInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE136ENS_8TermInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE118ENS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE119ENS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE190ENS_43OwnershipForwardingMultipleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single SILValue operand.
  struct __CxxTemplateInstN5swift20UnaryInstructionBaseILNS_18SILInstructionKindE191ENS_43OwnershipForwardingMultipleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE82ENS_11BuiltinInstENS_22SingleValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE8ENS_12AllocRefInstENS_16AllocRefInstBaseEJNS_7SILTypeEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE9ENS_19AllocRefDynamicInstENS_16AllocRefInstBaseEJNS_7SILTypeEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE10ENS_20AllocValueBufferInstENS_14AllocationInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE11ENS_12AllocBoxInstENS_14AllocationInstEJcEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE12ENS_23AllocExistentialBoxInstENS_14AllocationInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE171ENS_22MarkFunctionEscapeInstENS_19NonValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE160ENS_14BindMemoryInstENS_19NonValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE44ENS_19ConvertFunctionInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE45ENS_27ConvertEscapeToNoEscapeInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE47ENS_25PointerToThinFunctionInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE30ENS_10UpcastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE33ENS_20UncheckedRefCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE35ENS_27UncheckedTrivialBitCastInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE36ENS_24UncheckedBitwiseCastInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE37ENS_22UncheckedValueCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE51ENS_23ThinToThickFunctionInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE57ENS_28UnconditionalCheckedCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE56ENS_33UnconditionalCheckedCastValueInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE92ENS_10StructInstENS_40AllArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE88ENS_10ObjectInstENS_42FirstArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE89ENS_9TupleInstENS_40AllArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE101ENS_14SelectEnumInstENS_37OwnershipForwardingSelectEnumInstBaseEJPNS_15EnumElementDeclEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE102ENS_18SelectEnumAddrInstENS_18SelectEnumInstBaseEJPNS_15EnumElementDeclEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE103ENS_15SelectValueInstENS_14SelectInstBaseIS2_NS_8SILValueENS_42FirstArgOwnershipForwardingSingleValueInstEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE84ENS_12MetatypeInstENS_22SingleValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE27ENS_14ObjCMethodInstENS_10MethodInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE29ENS_17WitnessMethodInstENS_10MethodInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE104ENS_23InitExistentialAddrInstENS_22SingleValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE105ENS_24InitExistentialValueInstENS_22SingleValueInstructionEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE107ENS_22InitExistentialRefInstENS_42FirstArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE109ENS_27InitExistentialMetatypeInstENS_22SingleValueInstructionEJNS_22ProtocolConformanceRefEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE127ENS_9YieldInstENS_8TermInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE130ENS_10BranchInstENS_8TermInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE131ENS_14CondBranchInstENS_8TermInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE132ENS_15SwitchValueInstENS_8TermInstEJNS_12SILSuccessorEEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE137ENS_21CheckedCastBranchInstENS_18CastBranchInstBaseINS_27OwnershipForwardingTermInstEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE139ENS_26CheckedCastValueBranchInstENS_18CastBranchInstBaseINS_8TermInstEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE138ENS_25CheckedCastAddrBranchInstENS_17TypesForAddrCastsINS_33CastBranchWithConsumptionKindBaseEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE183ENS_24UncheckedRefCastAddrInstENS_17TypesForAddrCastsINS_19NonValueInstructionEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE34ENS_21UncheckedAddrCastInstENS_14ConversionInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE182ENS_32UnconditionalCheckedCastAddrInstENS_17TypesForAddrCastsINS_19NonValueInstructionEEEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE116ENS_26DifferentiableFunctionInstENS_40AllArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that a variable number of SILValue
  /// operands, and has zero or one value results. The operands are tail allocated
  /// after the instruction. Further trailing data can be allocated as well if
  /// OtherTrailingTypes are provided.
  struct __CxxTemplateInstN5swift35InstructionBaseWithTrailingOperandsILNS_18SILInstructionKindE117ENS_18LinearFunctionInstENS_40AllArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func numTrailingObjects(_: llvm.trailing_objects_internal.TrailingObjectsBase.__CxxTemplateInstN4llvm25trailing_objects_internal19TrailingObjectsBase13OverloadTokenIN5swift7OperandEEE) -> Int
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE10ENS_20AllocValueBufferInstENS_14AllocationInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE44ENS_19ConvertFunctionInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE45ENS_27ConvertEscapeToNoEscapeInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE47ENS_25PointerToThinFunctionInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE30ENS_10UpcastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE33ENS_20UncheckedRefCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE35ENS_27UncheckedTrivialBitCastInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE36ENS_24UncheckedBitwiseCastInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE37ENS_22UncheckedValueCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE51ENS_23ThinToThickFunctionInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE57ENS_28UnconditionalCheckedCastInstENS_33OwnershipForwardingConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE56ENS_33UnconditionalCheckedCastValueInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE27ENS_14ObjCMethodInstENS_10MethodInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE104ENS_23InitExistentialAddrInstENS_22SingleValueInstructionEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE105ENS_24InitExistentialValueInstENS_22SingleValueInstructionEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE107ENS_22InitExistentialRefInstENS_42FirstArgOwnershipForwardingSingleValueInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE109ENS_27InitExistentialMetatypeInstENS_22SingleValueInstructionEJNS_22ProtocolConformanceRefEEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE137ENS_21CheckedCastBranchInstENS_18CastBranchInstBaseINS_27OwnershipForwardingTermInstEEEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE139ENS_26CheckedCastValueBranchInstENS_18CastBranchInstBaseINS_8TermInstEEEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// A template base class for instructions that take a single regular SILValue
  /// operand, a set of type dependent operands and has no result
  /// or a single value result. The operands are tail allocated after the
  /// instruction. Further trailing data can be allocated as well if
  /// TRAILING_TYPES are provided.
  struct __CxxTemplateInstN5swift45UnaryInstructionWithTypeDependentOperandsBaseILNS_18SILInstructionKindE34ENS_21UncheckedAddrCastInstENS_14ConversionInstEJEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getOperand() -> swift.SILValue
    mutating func setOperand(_ V: swift.SILValue)
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Holds common debug information about local variables and function
  /// arguments that are needed by DebugValueInst, DebugValueAddrInst,
  /// AllocStackInst, and AllocBoxInst.
  struct SILDebugVariable {
    var Name: llvm.StringRef
    var ArgNo: UInt32
    var Constant: UInt32
    init()
    init(_ Constant: Bool, _ ArgNo: UInt16)
    init(_ Name: llvm.StringRef, _ Constant: Bool, _ ArgNo: UInt32)
    static func == (lhs: inout swift.SILDebugVariable, V: UnsafePointer<swift.SILDebugVariable>) -> Bool
  }

  /// A DebugVariable where storage for the strings has been
  /// tail-allocated following the parent SILInstruction.
  struct TailAllocatedDebugVariable {
    init(_: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE, _ buf: UnsafeMutablePointer<CChar>!)
    init(_ RawValue: UInt32)
    mutating func getRawValue() -> UInt32
    mutating func getArgNo() -> UInt32
    mutating func setArgNo(_ N: UInt32)

    /// Returns the name of the source variable, if it is stored in the
    /// instruction.
    mutating func getName(_ buf: UnsafePointer<CChar>!) -> llvm.StringRef
    mutating func isLet() -> Bool
    mutating func get(_ VD: UnsafeMutablePointer<swift.VarDecl>!, _ buf: UnsafePointer<CChar>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE
  }

  /// DeallocStackInst - Deallocate stack memory allocated by alloc_stack.
  struct DeallocStackInst {
  }

  /// AllocStackInst - This represents the allocation of an unboxed (i.e., no
  /// reference count) stack memory.  The memory is provided uninitialized.
  struct AllocStackInst {

    /// Set to true that this alloc_stack contains a value whose lifetime can not
    /// be ascertained from uses.
    ///
    /// As an example if an alloc_stack is known to be only conditionally
    /// initialized.
    mutating func setDynamicLifetime()

    /// Returns true if the alloc_stack's initialization can not be ascertained
    /// from uses directly (so should be treated conservatively).
    ///
    /// An example of an alloc_stack with dynamic lifetime is an alloc_stack that
    /// is conditionally initialized.
    mutating func hasDynamicLifetime() -> Bool

    /// Return the debug variable information attached to this instruction.
    mutating func getVarInfo() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE
    mutating func setArgNo(_ N: UInt32)

    /// getElementType - Get the type of the allocated memory (as opposed to the
    /// type of the instruction itself, which will be an address type).
    mutating func getElementType() -> swift.SILType
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Return a single dealloc_stack user or null.
    mutating func getSingleDeallocStack() -> UnsafeMutablePointer<swift.DeallocStackInst>!
  }

  /// The base class for AllocRefInst and AllocRefDynamicInst.
  ///
  /// The first NumTailTypes operands are counts for the tail allocated
  /// elements, the remaining operands are opened archetype operands.
  struct AllocRefInstBase {
    mutating func canAllocOnStack() -> Bool
    mutating func setStackAllocatable(_ OnStack: Bool)
    mutating func getTailAllocatedTypes() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7SILTypeEEE
    mutating func getTailAllocatedTypes() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7SILTypeEEE
    mutating func getTailAllocatedCounts() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTailAllocatedCounts() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Whether to use Objective-C's allocation mechanism (+allocWithZone:).
    mutating func isObjC() -> Bool
  }

  /// AllocRefInst - This represents the primitive allocation of an instance
  /// of a reference type. Aside from the reference count, the instance is
  /// returned uninitialized.
  /// Optionally, the allocated instance contains space for one or more tail-
  /// allocated arrays.
  struct AllocRefInst {
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// AllocRefDynamicInst - This represents the primitive allocation of
  /// an instance of a reference type whose runtime type is provided by
  /// the given metatype value. Aside from the reference count, the
  /// instance is returned uninitialized.
  /// Optionally, the allocated instance contains space for one or more tail-
  /// allocated arrays.
  struct AllocRefDynamicInst {
    mutating func getMetatypeOperand() -> swift.SILValue
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// AllocValueBufferInst - Allocate memory in a value buffer.
  struct AllocValueBufferInst {
    mutating func getValueType() -> swift.SILType
  }

  /// This represents the allocation of a heap box for a Swift value of some type.
  /// The instruction returns two values.  The first return value is the object
  /// pointer with Builtin.NativeObject type.  The second return value
  /// is an address pointing to the contained element. The contained
  /// element is uninitialized.
  struct AllocBoxInst {
    mutating func setDynamicLifetime()
    mutating func hasDynamicLifetime() -> Bool
    mutating func getAddressType() -> swift.SILType

    /// Return the debug variable information attached to this instruction.
    mutating func getVarInfo() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// This represents the allocation of a heap box for an existential container.
  /// The instruction returns two values.  The first return value is the owner
  /// pointer, which has the existential type.  The second return value
  /// is an address pointing to the contained element. The contained
  /// value is uninitialized.
  struct AllocExistentialBoxInst {
    mutating func getFormalConcreteType() -> swift.CanType
    mutating func getExistentialType() -> swift.SILType
    mutating func getConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// GenericSpecializationInformation - provides information about a generic
  /// specialization. This meta-information is created for each generic
  /// specialization, which allows for tracking of dependencies between
  /// specialized generic functions and can be used to detect specialization loops
  /// during generic specialization.
  struct GenericSpecializationInformation {
    static func create(_ Caller: UnsafeMutablePointer<swift.SILFunction>!, _ Parent: UnsafeMutablePointer<swift.SILFunction>!, _ Subs: swift.SubstitutionMap) -> UnsafePointer<swift.GenericSpecializationInformation>!
    static func create(_ Inst: UnsafeMutablePointer<swift.SILInstruction>!, _ B: UnsafeMutablePointer<swift.SILBuilder>) -> UnsafePointer<swift.GenericSpecializationInformation>!
    mutating func getCaller() -> UnsafePointer<swift.SILFunction>!
    mutating func getParent() -> UnsafePointer<swift.SILFunction>!
    mutating func getSubstitutions() -> swift.SubstitutionMap
  }

  /// PartialApplyInst - Represents the creation of a closure object by partial
  /// application of a function value.
  struct PartialApplyInst {
    struct OnStackKind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }
    mutating func hasCalleeGuaranteedContext() -> Bool
    mutating func isOnStack() -> swift.PartialApplyInst.OnStackKind
  }
  struct TerribleOverloadTokenHack {
    init()
  }

  /// The partial specialization of ApplyInstBase for full applications.
  /// Adds some methods relating to 'self' and to result types that don't
  /// make sense for partial applications.
  struct __CxxTemplateInstN5swift13ApplyInstBaseINS_9ApplyInstENS_22SingleValueInstructionELb1EEE {

    /// The collection of following routines wrap the representation difference in
    /// between the self substitution being first, but the self parameter of a
    /// function being last.
    ///
    /// The hope is that this will prevent any future bugs from coming up related
    /// to this.
    ///
    /// Self is always the last parameter, but self substitutions are always
    /// first. The reason to add this method is to wrap that dichotomy to reduce
    /// errors.
    ///
    /// FIXME: Could this be standardized? It has and will lead to bugs. IMHO.
    mutating func getSelfArgument() -> swift.SILValue
    mutating func getSelfArgumentOperand() -> UnsafeMutablePointer<swift.Operand>
    mutating func setSelfArgument(_ V: swift.SILValue)
    mutating func getArgumentsWithoutSelf() -> swift.OperandValueArrayRef
    mutating func getSingleResult() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13SILResultInfoEEE
    mutating func hasIndirectResults() -> Bool
    mutating func getNumIndirectResults() -> UInt32
    mutating func hasSelfArgument() -> Bool
    mutating func hasGuaranteedSelfArgument() -> Bool
    mutating func getIndirectSILResults() -> swift.OperandValueArrayRef
    mutating func getArgumentsWithoutIndirectResults() -> swift.OperandValueArrayRef

    /// Returns all `@inout` and `@inout_aliasable` arguments passed to the
    /// instruction.
    mutating func getInoutArguments() -> swift.InoutArgumentRange
    mutating func hasSemantics(_ semanticsString: llvm.StringRef) -> Bool
  }

  /// The partial specialization of ApplyInstBase for full applications.
  /// Adds some methods relating to 'self' and to result types that don't
  /// make sense for partial applications.
  struct __CxxTemplateInstN5swift13ApplyInstBaseINS_14BeginApplyInstENS_24MultipleValueInstructionELb1EEE {

    /// The collection of following routines wrap the representation difference in
    /// between the self substitution being first, but the self parameter of a
    /// function being last.
    ///
    /// The hope is that this will prevent any future bugs from coming up related
    /// to this.
    ///
    /// Self is always the last parameter, but self substitutions are always
    /// first. The reason to add this method is to wrap that dichotomy to reduce
    /// errors.
    ///
    /// FIXME: Could this be standardized? It has and will lead to bugs. IMHO.
    mutating func getSelfArgument() -> swift.SILValue
    mutating func getSelfArgumentOperand() -> UnsafeMutablePointer<swift.Operand>
    mutating func setSelfArgument(_ V: swift.SILValue)
    mutating func getArgumentsWithoutSelf() -> swift.OperandValueArrayRef
    mutating func getSingleResult() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13SILResultInfoEEE
    mutating func hasIndirectResults() -> Bool
    mutating func getNumIndirectResults() -> UInt32
    mutating func hasSelfArgument() -> Bool
    mutating func hasGuaranteedSelfArgument() -> Bool
    mutating func getIndirectSILResults() -> swift.OperandValueArrayRef
    mutating func getArgumentsWithoutIndirectResults() -> swift.OperandValueArrayRef

    /// Returns all `@inout` and `@inout_aliasable` arguments passed to the
    /// instruction.
    mutating func getInoutArguments() -> swift.InoutArgumentRange
    mutating func hasSemantics(_ semanticsString: llvm.StringRef) -> Bool
  }

  /// The partial specialization of ApplyInstBase for full applications.
  /// Adds some methods relating to 'self' and to result types that don't
  /// make sense for partial applications.
  struct __CxxTemplateInstN5swift13ApplyInstBaseINS_12TryApplyInstENS_16TryApplyInstBaseELb1EEE {

    /// The collection of following routines wrap the representation difference in
    /// between the self substitution being first, but the self parameter of a
    /// function being last.
    ///
    /// The hope is that this will prevent any future bugs from coming up related
    /// to this.
    ///
    /// Self is always the last parameter, but self substitutions are always
    /// first. The reason to add this method is to wrap that dichotomy to reduce
    /// errors.
    ///
    /// FIXME: Could this be standardized? It has and will lead to bugs. IMHO.
    mutating func getSelfArgument() -> swift.SILValue
    mutating func getSelfArgumentOperand() -> UnsafeMutablePointer<swift.Operand>
    mutating func setSelfArgument(_ V: swift.SILValue)
    mutating func getArgumentsWithoutSelf() -> swift.OperandValueArrayRef
    mutating func getSingleResult() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift13SILResultInfoEEE
    mutating func hasIndirectResults() -> Bool
    mutating func getNumIndirectResults() -> UInt32
    mutating func hasSelfArgument() -> Bool
    mutating func hasGuaranteedSelfArgument() -> Bool
    mutating func getIndirectSILResults() -> swift.OperandValueArrayRef
    mutating func getArgumentsWithoutIndirectResults() -> swift.OperandValueArrayRef

    /// Returns all `@inout` and `@inout_aliasable` arguments passed to the
    /// instruction.
    mutating func getInoutArguments() -> swift.InoutArgumentRange
    mutating func hasSemantics(_ semanticsString: llvm.StringRef) -> Bool
  }

  /// Given the callee operand of an apply or try_apply instruction,
  /// does it have the given semantics?
  static func doesApplyCalleeHaveSemantics(_ callee: swift.SILValue, _ semantics: llvm.StringRef) -> Bool

  /// Predicate used to filter InoutArgumentRange.
  struct OperandToInoutArgument {
    var paramInfos: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift16SILParameterInfoEEE
    var arguments: swift.OperandValueArrayRef
    init(_ paramInfos: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift16SILParameterInfoEEE, _ arguments: swift.OperandValueArrayRef)
  }
  typealias InoutArgumentRange = swift.__CxxTemplateInstN5swift22OptionalTransformRangeINS_8IntRangeImNS_14IntRangeTraitsImLb0EEEEENS_22OperandToInoutArgumentENS4_8iteratorEEE

  /// ApplyInst - Represents the full application of a function value.
  struct ApplyInst {

    /// Returns true if the called function has an error result but is not actually
    /// throwing an error.
    mutating func isNonThrowing() -> Bool
  }

  /// BeginApplyInst - Represents the beginning of the full application of
  /// a yield_once coroutine (up until the coroutine yields a value back).
  struct BeginApplyInst {
    mutating func getTokenResult() -> swift.SILValue
    mutating func getYieldedValues() -> swift.SILInstructionResultArray

    /// Returns true if the called coroutine has an error result but is not
    /// actually throwing an error.
    mutating func isNonThrowing() -> Bool
  }
  struct BeginApplyResult {
    init(_ index: UInt32, _ type: swift.SILType, _ ownershipKind: swift.ValueOwnershipKind)
    mutating func getParent() -> UnsafeMutablePointer<swift.BeginApplyInst>!
    mutating func getParent() -> UnsafePointer<swift.BeginApplyInst>!

    /// Is this result the token result of the begin_apply, which abstracts
    /// over the implicit coroutine state?
    mutating func isTokenResult() -> Bool
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// EndApplyInst - Resume the full application of a yield_once coroutine
  /// normally.
  struct EndApplyInst {
    mutating func getBeginApply() -> UnsafeMutablePointer<swift.BeginApplyInst>!
  }

  /// AbortApplyInst - Unwind the full application of a yield_once coroutine.
  struct AbortApplyInst {
    mutating func getBeginApply() -> UnsafeMutablePointer<swift.BeginApplyInst>!
  }

  /// Abstract base class for literal instructions.
  struct LiteralInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }

  /// FunctionRefInst - Represents a reference to a SIL function.
  struct FunctionRefInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ node: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct DynamicFunctionRefInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ node: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }
  struct PreviousDynamicFunctionRefInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ node: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }

  /// Component of a KeyPathInst.
  struct KeyPathPatternComponent {

    /// Computed property components require an identifier so they can be stably
    /// identified at runtime. This has to correspond to the ABI of the property--
    /// whether a reabstracted stored property, a property dispatched through a
    /// vtable or witness table, or a computed property.
    struct ComputedPropertyId {
      struct KindType : Equatable, RawRepresentable {
        init(_ rawValue: UInt32)
        init(rawValue: UInt32)
        var rawValue: UInt32
        typealias RawValue = UInt32
      }
      init()
      init(_ property: UnsafeMutablePointer<swift.VarDecl>!)
      init(_ function: UnsafeMutablePointer<swift.SILFunction>!)
      init(_ declRef: swift.SILDeclRef)
      mutating func getKind() -> swift.KeyPathPatternComponent.ComputedPropertyId.KindType
      mutating func getProperty() -> UnsafeMutablePointer<swift.VarDecl>!
      mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!
      mutating func getDeclRef() -> swift.SILDeclRef
    }
    enum Kind : UInt32 {
      init?(rawValue: UInt32)
      var rawValue: UInt32 { get }
      typealias RawValue = UInt32
      case StoredProperty
      case GettableProperty
      case SettableProperty
      case TupleElement
      case OptionalChain
      case OptionalForce
      case OptionalWrap
    }
    struct Index {
      var Operand: UInt32
      var FormalType: swift.CanType
      var LoweredType: swift.SILType
      var Hashable: swift.ProtocolConformanceRef
      init()
      init(Operand: UInt32, FormalType: swift.CanType, LoweredType: swift.SILType, Hashable: swift.ProtocolConformanceRef)
    }
    init()
    mutating func isNull() -> Bool
    mutating func getKind() -> swift.KeyPathPatternComponent.Kind
    mutating func getComponentType() -> swift.CanType
    mutating func getStoredPropertyDecl() -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getComputedPropertyId() -> swift.KeyPathPatternComponent.ComputedPropertyId
    mutating func getComputedPropertyGetter() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getComputedPropertySetter() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getSubscriptIndices() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponent5IndexEEE
    mutating func getSubscriptIndexEquals() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func getSubscriptIndexHash() -> UnsafeMutablePointer<swift.SILFunction>!
    mutating func isComputedSettablePropertyMutating() -> Bool
    static func forStoredProperty(_ property: UnsafeMutablePointer<swift.VarDecl>!, _ ty: swift.CanType) -> swift.KeyPathPatternComponent
    mutating func getExternalDecl() -> UnsafeMutablePointer<swift.AbstractStorageDecl>!
    mutating func getExternalSubstitutions() -> swift.SubstitutionMap
    mutating func getTupleIndex() -> UInt32
    static func forComputedGettableProperty(_ identifier: swift.KeyPathPatternComponent.ComputedPropertyId, _ getter: UnsafeMutablePointer<swift.SILFunction>!, _ indices: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponent5IndexEEE, _ indicesEquals: UnsafeMutablePointer<swift.SILFunction>!, _ indicesHash: UnsafeMutablePointer<swift.SILFunction>!, _ externalDecl: UnsafeMutablePointer<swift.AbstractStorageDecl>!, _ externalSubs: swift.SubstitutionMap, _ ty: swift.CanType) -> swift.KeyPathPatternComponent
    static func forComputedSettableProperty(_ identifier: swift.KeyPathPatternComponent.ComputedPropertyId, _ getter: UnsafeMutablePointer<swift.SILFunction>!, _ setter: UnsafeMutablePointer<swift.SILFunction>!, _ indices: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift23KeyPathPatternComponent5IndexEEE, _ indicesEquals: UnsafeMutablePointer<swift.SILFunction>!, _ indicesHash: UnsafeMutablePointer<swift.SILFunction>!, _ externalDecl: UnsafeMutablePointer<swift.AbstractStorageDecl>!, _ externalSubs: swift.SubstitutionMap, _ ty: swift.CanType) -> swift.KeyPathPatternComponent
    static func forOptional(_ kind: swift.KeyPathPatternComponent.Kind, _ ty: swift.CanType) -> swift.KeyPathPatternComponent
    static func forTupleElement(_ tupleIndex: UInt32, _ ty: swift.CanType) -> swift.KeyPathPatternComponent
    mutating func visitReferencedFunctionsAndMethods(_ functionCallBack: std.__1.__CxxTemplateInstNSt3__18functionIFvPN5swift11SILFunctionEEEE, _ methodCallBack: std.__1.__CxxTemplateInstNSt3__18functionIFvN5swift10SILDeclRefEEEE)
    mutating func incrementRefCounts()
    mutating func decrementRefCounts()
    mutating func Profile(_ ID: UnsafeMutablePointer<llvm.FoldingSetNodeID>)
  }

  /// Base class for instructions that access the continuation of an async task,
  /// in order to set up a suspension.
  /// The continuation must be consumed by an AwaitAsyncContinuation instruction locally,
  /// and must dynamically be resumed exactly once during the program's ensuing execution.
  struct GetAsyncContinuationInstBase {

    /// Get the type of the value the async task receives on a resume.
    mutating func getFormalResumeType() -> swift.CanType
    mutating func getLoweredResumeType() -> swift.SILType

    /// True if the continuation can be used to resume the task by throwing an error.
    mutating func `throws`() -> Bool
    static func classof(_ I: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Accesses the continuation for an async task, to prepare a primitive suspend operation.
  struct GetAsyncContinuationInst {
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Accesses the continuation for an async task, to prepare a primitive suspend operation.
  /// The continuation must be consumed by an AwaitAsyncContinuation instruction locally,
  /// and must dynamically be resumed exactly once during the program's ensuing execution.
  ///
  /// This variation of the instruction additionally takes an operand for the address of the
  /// buffer that receives the incoming value when the continuation is resumed.
  struct GetAsyncContinuationAddrInst {
  }

  /// Begins a suspension point and enqueues the continuation to the executor
  /// which is bound to the operand actor.
  struct HopToExecutorInst {
    mutating func getActor() -> swift.SILValue
  }

  /// Instantiates a key path object.
  struct KeyPathInst {
    mutating func getPattern() -> UnsafeMutablePointer<swift.KeyPathPattern>!
    mutating func hasPattern() -> Bool
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSubstitutions() -> swift.SubstitutionMap
    mutating func dropReferencedPattern()
  }

  /// Represents an invocation of builtin functionality provided by the code
  /// generator.
  struct BuiltinInst {

    /// Return the name of the builtin operation.
    mutating func getName() -> swift.Identifier
    mutating func setName(_ I: swift.Identifier)

    /// Looks up the llvm intrinsic ID and type for the builtin function.
    ///
    /// \returns Returns llvm::Intrinsic::not_intrinsic if the function is not an
    /// intrinsic. The particular intrinsic functions which correspond to the
    /// returned value are defined in llvm/Intrinsics.h.
    mutating func getIntrinsicInfo() -> UnsafePointer<swift.IntrinsicInfo>

    /// Looks up the lazily cached identification for the builtin function.
    mutating func getBuiltinInfo() -> UnsafePointer<swift.BuiltinInfo>

    /// Looks up the llvm intrinsic ID of this builtin. Returns None if
    /// this is not an intrinsic.
    mutating func getIntrinsicID() -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE

    /// Looks up the BuiltinKind of this builtin. Returns None if this is
    /// not a builtin.
    mutating func getBuiltinKind() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16BuiltinValueKindEEE

    /// True if this builtin application has substitutions, which represent type
    /// parameters to the builtin.
    mutating func hasSubstitutions() -> Bool

    /// Return the type parameters to the builtin.
    mutating func getSubstitutions() -> swift.SubstitutionMap

    /// The arguments to the builtin.
    mutating func getArguments() -> swift.OperandValueArrayRef
  }

  /// Initializes a SIL global variable. Only valid once, before any
  /// usages of the global via GlobalAddrInst.
  struct AllocGlobalInst {

    /// Return the referenced global variable.
    mutating func getReferencedGlobal() -> UnsafeMutablePointer<swift.SILGlobalVariable>!
    mutating func setReferencedGlobal(_ v: UnsafeMutablePointer<swift.SILGlobalVariable>!)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// The base class for global_addr and global_value.
  struct GlobalAccessInst {

    /// Return the referenced global variable.
    mutating func getReferencedGlobal() -> UnsafeMutablePointer<swift.SILGlobalVariable>!
    mutating func setReferencedGlobal(_ v: UnsafeMutablePointer<swift.SILGlobalVariable>!)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Gives the address of a SIL global variable. Only valid after an
  /// AllocGlobalInst.
  struct GlobalAddrInst {

    /// Create a placeholder instruction with an unset global reference.
    init(_ DebugLoc: swift.SILDebugLocation, _ Ty: swift.SILType)
  }

  /// Creates a base address for offset calculations.
  struct BaseAddrForOffsetInst {
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Gives the value of a global variable.
  ///
  /// The referenced global variable must be a statically initialized object.
  /// TODO: in future we might support global variables in general.
  struct GlobalValueInst {
  }

  /// IntegerLiteralInst - Encapsulates an integer constant, as defined originally
  /// by an IntegerLiteralExpr.
  struct IntegerLiteralInst {

    /// getValue - Return the APInt for the underlying integer literal.
    mutating func getValue() -> llvm.APInt
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// FloatLiteralInst - Encapsulates a floating point constant, as defined
  /// originally by a FloatLiteralExpr.
  struct FloatLiteralInst {

    /// Return the APFloat for the underlying FP literal.
    mutating func getValue() -> llvm.APFloat

    /// Return the bitcast representation of the FP literal as an APInt.
    mutating func getBits() -> llvm.APInt
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// StringLiteralInst - Encapsulates a string constant, as defined originally by
  /// a StringLiteralExpr.  This produces the address of the string data as a
  /// Builtin.RawPointer.
  struct StringLiteralInst {
    enum Encoding : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case Bytes
      case UTF8

      /// UTF-8 encoding of an Objective-C selector.
      case ObjCSelector
    }

    /// getValue - Return the string data for the literal, in UTF-8.
    mutating func getValue() -> llvm.StringRef

    /// getEncoding - Return the desired encoding of the text.
    mutating func getEncoding() -> swift.StringLiteralInst.Encoding

    /// getCodeUnitCount - Return encoding-based length of the string
    /// literal in code units.
    mutating func getCodeUnitCount() -> UInt64
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// StringLiteralInst::Encoding hashes to its underlying integer representation.
  static func hash_value(_ E: swift.StringLiteralInst.Encoding) -> llvm.hash_code
  enum LoadOwnershipQualifier : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case Unqualified
    case Take
    case Copy
    case Trivial
  }

  /// LoadInst - Represents a load from a memory location.
  struct LoadInst {
    mutating func getOwnershipQualifier() -> swift.LoadOwnershipQualifier
    mutating func setOwnershipQualifier(_ qualifier: swift.LoadOwnershipQualifier)
  }
  enum StoreOwnershipQualifier : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case Unqualified
    case Init
    case Assign
    case Trivial
  }

  /// StoreInst - Represents a store from a memory location.
  struct StoreInst {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getOwnershipQualifier() -> swift.StoreOwnershipQualifier
    mutating func setOwnershipQualifier(_ qualifier: swift.StoreOwnershipQualifier)
  }

  /// Represents the end of a borrow scope of a value %val from a
  /// value or address %src.
  ///
  /// While %val is "live" in a region then,
  ///
  ///   1. If %src is an object, it is undefined behavior for %src to be
  ///   destroyed. This is enforced by the ownership verifier.
  ///
  ///   2. If %src is an address, it is undefined behavior for %src to be
  ///   destroyed or written to.
  struct EndBorrowInst {

    /// Return the value that this end_borrow is ending the borrow of if we are
    /// borrowing a single value.
    mutating func getSingleOriginalValue() -> swift.SILValue

    /// Return the set of guaranteed values that have scopes ended by this
    /// end_borrow.
    ///
    /// Discussion: We can only have multiple values associated with an end_borrow
    /// in the case of having Phi arguments with guaranteed inputs. This is
    /// necessary to represent certain conditional operations such as:
    ///
    /// class Klass {
    ///   let k1: Klass
    ///   let k2: Klass
    /// }
    ///
    /// func useKlass(k: Klass) { ... }
    /// var boolValue : Bool { ... }
    ///
    /// func f(k: Klass) {
    ///   useKlass(boolValue ? k.k1 : k.k2)
    /// }
    ///
    /// Today, when we SILGen such code, we copy k.k1 and k.k2 before the Phi when
    /// it could potentially be avoided. So today this just appends
    /// getSingleOriginalValue() to originalValues.
    ///
    /// TODO: Once this changes, this code must be update.
    mutating func getOriginalValues(_ originalValues: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIN5swift8SILValueEEE>)
  }

  /// Represents a load of a borrowed value. Must be paired with an end_borrow
  /// instruction in its use-def list.
  struct LoadBorrowInst {
    typealias EndBorrowRange = swift.__CxxTemplateInstN5swift19DowncastFilterRangeINS_13EndBorrowInstEN4llvm14iterator_rangeINS2_15mapped_iteratorINS_20ValueBaseUseIteratorENS_9ValueBase9UseToUserEPNS_14SILInstructionEEEEEEE
    init(_ DebugLoc: swift.SILDebugLocation, _ LValue: swift.SILValue)

    /// Return a range over all EndBorrow instructions for this BeginBorrow.
    mutating func getEndBorrows() -> swift.LoadBorrowInst.EndBorrowRange
  }

  /// Represents the begin scope of a borrowed value. Must be paired with an
  /// end_borrow instruction in its use-def list.
  struct BeginBorrowInst {
    typealias EndBorrowRange = swift.__CxxTemplateInstN5swift19DowncastFilterRangeINS_13EndBorrowInstEN4llvm14iterator_rangeINS2_15mapped_iteratorINS_20ValueBaseUseIteratorENS_9ValueBase9UseToUserEPNS_14SILInstructionEEEEEEE

    /// Return a range over all EndBorrow instructions for this BeginBorrow.
    mutating func getEndBorrows() -> swift.BeginBorrowInst.EndBorrowRange

    /// Return the single use of this BeginBorrowInst, not including any
    /// EndBorrowInst uses, or return nullptr if the borrow is dead or has
    /// multiple uses.
    ///
    /// Useful for matching common SILGen patterns that emit one borrow per use,
    /// and simplifying pass logic.
    mutating func getSingleNonEndingUse() -> UnsafeMutablePointer<swift.Operand>!
  }

  /// Represents a store of a borrowed value into an address. Returns the borrowed
  /// address. Must be paired with an end_borrow in its use-def list.
  struct StoreBorrowInst {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Different kinds of access.
  enum SILAccessKind : UInt8 {
    init?(rawValue: UInt8)
    var rawValue: UInt8 { get }
    typealias RawValue = UInt8

    /// An access which takes uninitialized memory and initializes it.
    case Init

    /// An access which reads the value of initialized memory, but doesn't
    /// modify it.
    case Read

    /// An access which changes the value of initialized memory.
    case Modify

    /// An access which takes initialized memory and leaves it uninitialized.
    case Deinit

    /// An access which takes initialized memory and leaves it uninitialized.
    static var Last: swift.SILAccessKind { get }
  }
  static func getSILAccessKindName(_ kind: swift.SILAccessKind) -> llvm.StringRef

  /// Different kinds of exclusivity enforcement for accesses.
  enum SILAccessEnforcement : UInt8 {
    init?(rawValue: UInt8)
    var rawValue: UInt8 { get }
    typealias RawValue = UInt8

    /// The access's enforcement has not yet been determined.
    case Unknown

    /// The access is statically known to not conflict with other accesses.
    case Static

    /// The access is not statically known to not conflict with anything
    /// and must be dynamically checked.
    case Dynamic

    /// The access is not statically known to not conflict with anything
    /// but dynamic checking should be suppressed, leaving it undefined
    /// behavior.
    case Unsafe

    /// The access is not statically known to not conflict with anything
    /// but dynamic checking should be suppressed, leaving it undefined
    /// behavior.
    static var Last: swift.SILAccessEnforcement { get }
  }
  static func getSILAccessEnforcementName(_ enforcement: swift.SILAccessEnforcement) -> llvm.StringRef

  /// Represents the end of an access scope.
  struct EndAccessInst {

    /// An aborted access is one that did not perform the expected
    /// transition described by the begin_access instruction before it
    /// reached this end_access.
    ///
    /// Only AccessKind::Init and AccessKind::Deinit accesses can be
    /// aborted.
    mutating func isAborting() -> Bool
    mutating func setAborting(_ aborting: Bool)
    mutating func getBeginAccess() -> UnsafeMutablePointer<swift.BeginAccessInst>!
    mutating func getSource() -> swift.SILValue
  }

  /// Begins an access scope. Must be paired with an end_access instruction
  /// along every path.
  struct BeginAccessInst {
    typealias EndAccessRange = swift.__CxxTemplateInstN5swift19DowncastFilterRangeINS_13EndAccessInstEN4llvm14iterator_rangeINS2_15mapped_iteratorINS_20ValueBaseUseIteratorENS_9ValueBase9UseToUserEPNS_14SILInstructionEEEEEEE
    mutating func getAccessKind() -> swift.SILAccessKind
    mutating func setAccessKind(_ kind: swift.SILAccessKind)
    mutating func getEnforcement() -> swift.SILAccessEnforcement
    mutating func setEnforcement(_ enforcement: swift.SILAccessEnforcement)

    /// If hasNoNestedConflict is true, then it is a static guarantee against
    /// inner conflicts. No subsequent access between this point and the
    /// corresponding end_access could cause an enforcement failure. Consequently,
    /// the access will not need to be tracked by the runtime for the duration of
    /// its scope. This access may still conflict with an outer access scope;
    /// therefore may still require dynamic enforcement at a single point.
    mutating func hasNoNestedConflict() -> Bool
    mutating func setNoNestedConflict(_ noNestedConflict: Bool)

    /// Return true if this access marker was emitted for a user-controlled
    /// Builtin. Return false if this access marker was auto-generated by the
    /// compiler to enforce formal access that derives from the language.
    mutating func isFromBuiltin() -> Bool
    mutating func getSource() -> swift.SILValue

    /// Find all the associated end_access instructions for this begin_access.
    mutating func getEndAccesses() -> swift.BeginAccessInst.EndAccessRange
  }

  /// Begins an access without requiring a paired end_access.
  /// Dynamically, an end_unpaired_access does still need to be called, though.
  ///
  /// This should only be used in materializeForSet, and eventually it should
  /// be removed entirely.
  struct BeginUnpairedAccessInst {
    mutating func getAccessKind() -> swift.SILAccessKind
    mutating func setAccessKind(_ kind: swift.SILAccessKind)
    mutating func getEnforcement() -> swift.SILAccessEnforcement
    mutating func setEnforcement(_ enforcement: swift.SILAccessEnforcement)

    /// If hasNoNestedConflict is true, then it is a static guarantee against
    /// inner conflicts. No subsequent access between this point and the
    /// corresponding end_access could cause an enforcement failure. Consequently,
    /// the access will not need to be tracked by the runtime for the duration of
    /// its scope. This access may still conflict with an outer access scope;
    /// therefore may still require dynamic enforcement at a single point.
    mutating func hasNoNestedConflict() -> Bool
    mutating func setNoNestedConflict(_ noNestedConflict: Bool)

    /// Return true if this access marker was emitted for a user-controlled
    /// Builtin. Return false if this access marker was auto-generated by the
    /// compiler to enforce formal access that derives from the language.
    mutating func isFromBuiltin() -> Bool
    mutating func getSource() -> swift.SILValue
    mutating func getBuffer() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Ends an unpaired access.
  struct EndUnpairedAccessInst {

    /// An aborted access is one that did not perform the expected
    /// transition described by the begin_access instruction before it
    /// reached this end_access.
    ///
    /// Only AccessKind::Init and AccessKind::Deinit accesses can be
    /// aborted.
    mutating func isAborting() -> Bool
    mutating func setAborting(_ aborting: Bool)
    mutating func getEnforcement() -> swift.SILAccessEnforcement
    mutating func setEnforcement(_ enforcement: swift.SILAccessEnforcement)

    /// Return true if this access marker was emitted for a user-controlled
    /// Builtin. Return false if this access marker was auto-generated by the
    /// compiler to enforce formal access that derives from the language.
    mutating func isFromBuiltin() -> Bool
    mutating func getBuffer() -> swift.SILValue
  }
  enum AssignOwnershipQualifier : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32

    /// Unknown initialization method
    case Unknown

    /// The box contains a fully-initialized value.
    case Reassign

    /// The box contains a class instance that we own, but the instance has
    /// not been initialized and should be freed with a special SIL
    /// instruction made for this purpose.
    case Reinit

    /// The box contains an undefined value that should be ignored.
    case Init
  }
  struct __CxxTemplateInstN5swift14AssignInstBaseILNS_18SILInstructionKindE169ELi2EEE {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }
  struct __CxxTemplateInstN5swift14AssignInstBaseILNS_18SILInstructionKindE170ELi4EEE {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// AssignInst - Represents an abstract assignment to a memory location, which
  /// may either be an initialization or a store sequence.  This is only valid in
  /// Raw SIL.
  struct AssignInst {
    mutating func getOwnershipQualifier() -> swift.AssignOwnershipQualifier
    mutating func setOwnershipQualifier(_ qualifier: swift.AssignOwnershipQualifier)
  }

  /// AssignByWrapperInst - Represents an abstract assignment via a wrapper,
  /// which may either be an initialization or a store sequence.  This is only
  /// valid in Raw SIL.
  struct AssignByWrapperInst {

    /// The assignment destination for the property wrapper
    enum Destination : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32
      case BackingWrapper
      case WrappedValue
    }
    mutating func getInitializer() -> swift.SILValue
    mutating func getSetter() -> swift.SILValue
    mutating func getOwnershipQualifier() -> swift.AssignOwnershipQualifier
    mutating func getAssignDestination() -> swift.AssignByWrapperInst.Destination
    mutating func setAssignInfo(_ qualifier: swift.AssignOwnershipQualifier, _ dest: swift.AssignByWrapperInst.Destination)
  }

  /// Indicates that a memory location is uninitialized at this point and needs to
  /// be initialized by the end of the function and before any escape point for
  /// this instruction. This is only valid in Raw SIL.
  struct MarkUninitializedInst {

    /// This enum captures what the mark_uninitialized instruction is designating.
    struct Kind : Equatable, RawRepresentable {
      init(_ rawValue: UInt32)
      init(rawValue: UInt32)
      var rawValue: UInt32
      typealias RawValue = UInt32
    }
    mutating func getMarkUninitializedKind() -> swift.MarkUninitializedInst.Kind
    mutating func isVar() -> Bool
    mutating func isRootSelf() -> Bool
    mutating func isCrossModuleRootSelf() -> Bool
    mutating func isDerivedClassSelf() -> Bool
    mutating func isDerivedClassSelfOnly() -> Bool
    mutating func isDelegatingSelf() -> Bool
    mutating func isDelegatingSelfAllocated() -> Bool
  }

  /// MarkFunctionEscape - Represents the escape point of set of variables due to
  /// a function definition which uses the variables.  This is only valid in Raw
  /// SIL.
  struct MarkFunctionEscapeInst {

    /// The elements referenced by this instruction.
    mutating func getElementOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// The elements referenced by this instruction.
    mutating func getElements() -> swift.OperandValueArrayRef
  }

  /// Define the start or update to a symbolic variable value (for loadable
  /// types).
  struct DebugValueInst {

    /// Return the underlying variable declaration that this denotes,
    /// or null if we don't have one.
    mutating func getDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Return the debug variable information attached to this instruction.
    mutating func getVarInfo() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE
  }

  /// Define the start or update to a symbolic variable value (for address-only
  /// types) .
  struct DebugValueAddrInst {

    /// Return the underlying variable declaration that this denotes,
    /// or null if we don't have one.
    mutating func getDecl() -> UnsafeMutablePointer<swift.VarDecl>!

    /// Return the debug variable information attached to this instruction.
    mutating func getVarInfo() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift16SILDebugVariableEEE
  }

  /// An abstract class representing a load from some kind of reference storage.
  struct __CxxTemplateInstN5swift21LoadReferenceInstBaseILNS_18SILInstructionKindE75EEE {
    mutating func isTake() -> swift.IsTake_t
  }

  /// An abstract class representing a load from some kind of reference storage.
  struct __CxxTemplateInstN5swift21LoadReferenceInstBaseILNS_18SILInstructionKindE76EEE {
    mutating func isTake() -> swift.IsTake_t
  }

  /// An abstract class representing a store to some kind of reference storage.
  struct __CxxTemplateInstN5swift22StoreReferenceInstBaseILNS_18SILInstructionKindE174EEE {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func isInitializationOfDest() -> swift.IsInitialization_t
    mutating func setIsInitializationOfDest(_ I: swift.IsInitialization_t)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// An abstract class representing a store to some kind of reference storage.
  struct __CxxTemplateInstN5swift22StoreReferenceInstBaseILNS_18SILInstructionKindE175EEE {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func isInitializationOfDest() -> swift.IsInitialization_t
    mutating func setIsInitializationOfDest(_ I: swift.IsInitialization_t)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }
  struct LoadWeakInst {
  }
  struct LoadUnownedInst {
  }
  struct StoreWeakInst {
  }
  struct StoreUnownedInst {
  }

  /// CopyAddrInst - Represents a copy from one memory location to another. This
  /// is similar to:
  ///   %1 = load %src
  ///   store %1 to %dest
  /// but a copy instruction must be used for address-only types.
  struct CopyAddrInst {
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func setSrc(_ V: swift.SILValue)
    mutating func setDest(_ V: swift.SILValue)
    mutating func isTakeOfSrc() -> swift.IsTake_t
    mutating func isInitializationOfDest() -> swift.IsInitialization_t
    mutating func setIsTakeOfSrc(_ T: swift.IsTake_t)
    mutating func setIsInitializationOfDest(_ I: swift.IsInitialization_t)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// BindMemoryInst -
  /// "bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T"
  /// Binds memory at the raw pointer %0 to type $T with enough capacity
  /// to hold $1 values.
  struct BindMemoryInst {
    mutating func getBase() -> swift.SILValue
    mutating func getIndex() -> swift.SILValue
    mutating func getBoundType() -> swift.SILType
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// ConversionInst - Abstract class representing instructions that convert
  /// values.
  ///
  struct ConversionInst {

    /// All conversion instructions take the converted value, whose reference
    /// identity is expected to be preserved through the conversion chain, as their
    /// first operand. Some instructions may take additional operands that do not
    /// affect the reference identity.
    mutating func getConverted() -> swift.SILValue
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }

  /// A conversion inst that produces a static OwnershipKind set upon the
  /// instruction's construction.
  struct OwnershipForwardingConversionInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
  }

  /// ConvertFunctionInst - Change the type of a function value without
  /// affecting how it will codegen.
  struct ConvertFunctionInst {

    /// Returns `true` if this converts a non-escaping closure into an escaping
    /// function type. `True` must be returned whenever the closure operand has an
    /// unboxed capture (via @inout_aliasable) *and* the resulting function type
    /// is escaping. (This only happens as a result of
    /// withoutActuallyEscaping()). If `true` is returned, then the resulting
    /// function type must be escaping, but the operand's function type may or may
    /// not be @noescape. Note that a non-escaping closure may have unboxed
    /// captured even though its SIL function type is "escaping".
    mutating func withoutActuallyEscaping() -> Bool

    /// Returns `true` if the function conversion is between types with the same
    /// argument and return types, as well as all other attributes, after substitution,
    /// such as converting `$<A, B> in (A) -> B for <Int, String>` to `(Int) -> String`.
    mutating func onlyConvertsSubstitutions() -> Bool
  }

  /// ConvertEscapeToNoEscapeInst - Change the type of a escaping function value
  /// to a trivial function type (@noescape T -> U).
  struct ConvertEscapeToNoEscapeInst {

    /// Return true if we have extended the lifetime of the argument of the
    /// convert_escape_to_no_escape to be over all uses of the trivial type.
    mutating func isLifetimeGuaranteed() -> Bool

    /// Mark that we have extended the lifetime of the argument of the
    /// convert_escape_to_no_escape to be over all uses of the trivial type.
    ///
    /// NOTE: This is a one way operation.
    mutating func setLifetimeGuaranteed()
  }

  /// ThinFunctionToPointerInst - Convert a thin function pointer to a
  /// Builtin.RawPointer.
  struct ThinFunctionToPointerInst {
  }

  /// PointerToThinFunctionInst - Convert a Builtin.RawPointer to a thin
  /// function pointer.
  struct PointerToThinFunctionInst {
  }

  /// UpcastInst - Perform a conversion of a class instance to a supertype.
  struct UpcastInst {
  }

  /// AddressToPointerInst - Convert a SIL address to a Builtin.RawPointer value.
  struct AddressToPointerInst {
  }

  /// PointerToAddressInst - Convert a Builtin.RawPointer value to a SIL address.
  struct PointerToAddressInst {

    /// Whether the returned address adheres to strict aliasing.
    /// If true, then the type of each memory access dependent on
    /// this address must be consistent with the memory's bound type.
    mutating func isStrict() -> Bool

    /// Whether the returned address is invariant.
    /// If true, then loading from an address derived from this pointer always
    /// produces the same value.
    mutating func isInvariant() -> Bool
  }

  /// Convert a heap object reference to a different type without any runtime
  /// checks.
  struct UncheckedRefCastInst {
  }

  /// Convert a value's binary representation to a trivial type of the same size.
  struct UncheckedTrivialBitCastInst {
  }

  /// Bitwise copy a value into another value of the same size or smaller.
  struct UncheckedBitwiseCastInst {
  }

  /// Bitwise copy a value into another value of the same size.
  struct UncheckedValueCastInst {
  }

  /// Build a Builtin.BridgeObject from a heap object reference by bitwise-or-ing
  /// in bits from a word.
  struct RefToBridgeObjectInst {
    mutating func getBitsOperand() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Extract the heap object reference from a BridgeObject.
  struct ClassifyBridgeObjectInst {
  }

  /// Extract the heap object reference from a BridgeObject.
  struct BridgeObjectToRefInst {
  }

  /// Sets the BridgeObject to a tagged pointer representation holding its
  /// operands
  struct ValueToBridgeObjectInst {
  }

  /// Retrieve the bit pattern of a BridgeObject.
  struct BridgeObjectToWordInst {
  }

  /// RefToRawPointer - Convert a reference type to a Builtin.RawPointer.
  struct RefToRawPointerInst {
  }

  /// RawPointerToRefInst - Convert a Builtin.RawPointer to a reference type.
  struct RawPointerToRefInst {
  }
  struct RefToUnownedInst {
  }
  struct UnownedToRefInst {
  }
  struct RefToUnmanagedInst {
  }
  struct UnmanagedToRefInst {
  }

  /// ThinToThickFunctionInst - Given a thin function reference, adds a null
  /// context to convert the value to a thick function type.
  struct ThinToThickFunctionInst {

    /// Return the callee of the thin_to_thick_function.
    ///
    /// This is not technically necessary, but from a symmetry perspective it
    /// makes sense to follow the lead of partial_apply which also creates
    /// closures.
    mutating func getCallee() -> swift.SILValue
  }

  /// Given a thick metatype value, produces an Objective-C metatype
  /// value.
  struct ThickToObjCMetatypeInst {
  }

  /// Given an Objective-C metatype value, produces a thick metatype
  /// value.
  struct ObjCToThickMetatypeInst {
  }

  /// Given an Objective-C metatype value, convert it to an AnyObject value.
  struct ObjCMetatypeToObjectInst {
  }

  /// Given an Objective-C existential metatype value, convert it to an AnyObject
  /// value.
  struct ObjCExistentialMetatypeToObjectInst {
  }

  /// Return the Objective-C Protocol class instance for a protocol.
  struct ObjCProtocolInst {
    mutating func getProtocol() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Perform an unconditional checked cast that aborts if the cast fails.
  struct UnconditionalCheckedCastInst {
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetFormalType() -> swift.CanType
    mutating func getTargetLoweredType() -> swift.SILType
  }

  /// Perform an unconditional checked cast that aborts if the cast fails.
  /// The result of the checked cast is left in the destination.
  struct UnconditionalCheckedCastValueInst {
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetLoweredType() -> swift.SILType
    mutating func getTargetFormalType() -> swift.CanType
  }

  /// StructInst - Represents a constructed loadable struct.
  struct StructInst {

    /// The elements referenced by this StructInst.
    mutating func getElementOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// The elements referenced by this StructInst.
    mutating func getElements() -> swift.OperandValueArrayRef
    mutating func getFieldValue(_ V: UnsafePointer<swift.VarDecl>!) -> swift.SILValue

    /// Return the Operand associated with the given VarDecl.
    mutating func getOperandForField(_ V: UnsafePointer<swift.VarDecl>!) -> UnsafePointer<swift.Operand>!
    mutating func getOperandForField(_ V: UnsafePointer<swift.VarDecl>!) -> UnsafeMutablePointer<swift.Operand>!

    /// Search the operands of this struct for a unique non-trivial field. If we
    /// find it, return it. Otherwise return SILValue().
    mutating func getUniqueNonTrivialFieldValue() -> swift.SILValue
    mutating func getStructDecl() -> UnsafeMutablePointer<swift.StructDecl>!
  }

  /// RefCountingInst - An abstract class of instructions which
  /// manipulate the reference count of their object operand.
  struct RefCountingInst {

    /// The atomicity of a reference counting operation to be used.
    enum Atomicity : Bool {
      init?(rawValue: Bool)
      var rawValue: Bool { get }
      typealias RawValue = Bool

      /// Atomic reference counting operations should be used.
      case Atomic

      /// Non-atomic reference counting operations can be used.
      case NonAtomic
    }
    mutating func setAtomicity(_ flag: swift.RefCountingInst.Atomicity)
    mutating func setNonAtomic()
    mutating func setAtomic()
    mutating func getAtomicity() -> swift.RefCountingInst.Atomicity
    mutating func isNonAtomic() -> Bool
    mutating func isAtomic() -> Bool
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// RetainValueInst - Copies a loadable value.
  struct RetainValueInst {
  }

  /// RetainValueAddrInst - Copies a loadable value by address.
  struct RetainValueAddrInst {
  }

  /// ReleaseValueInst - Destroys a loadable value.
  struct ReleaseValueInst {
  }

  /// ReleaseValueInst - Destroys a loadable value by address.
  struct ReleaseValueAddrInst {
  }

  /// Copies a loadable value in an unmanaged, unbalanced way. Only meant for use
  /// in ownership qualified SIL. Please do not use this EVER unless you are
  /// implementing a part of the stdlib called Unmanaged.
  struct UnmanagedRetainValueInst {
  }

  /// Destroys a loadable value in an unmanaged, unbalanced way. Only meant for
  /// use in ownership qualified SIL. Please do not use this EVER unless you are
  /// implementing a part of the stdlib called Unmanaged.
  struct UnmanagedReleaseValueInst {
  }

  /// Transfers ownership of a loadable value to the current autorelease
  /// pool. Unmanaged, so it is ignored from an ownership balancing perspective.
  struct UnmanagedAutoreleaseValueInst {
  }

  /// Transfers ownership of a loadable value to the current autorelease pool.
  struct AutoreleaseValueInst {
  }

  /// SetDeallocatingInst - Sets the operand in deallocating state.
  ///
  /// This is the same operation what's done by a strong_release immediately
  /// before it calls the deallocator of the object.
  struct SetDeallocatingInst {
  }

  /// ObjectInst - Represents a object value type.
  ///
  /// This instruction can only appear at the end of a gobal variable's
  /// static initializer list.
  struct ObjectInst {

    /// All elements referenced by this ObjectInst.
    mutating func getElementOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// All elements referenced by this ObjectInst.
    mutating func getAllElements() -> swift.OperandValueArrayRef

    /// The elements which initialize the stored properties of the object itself.
    mutating func getBaseElements() -> swift.OperandValueArrayRef

    /// The elements which initialize the tail allocated elements.
    mutating func getTailElements() -> swift.OperandValueArrayRef
  }

  /// TupleInst - Represents a constructed loadable tuple.
  struct TupleInst {

    /// The elements referenced by this TupleInst.
    mutating func getElementOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// The elements referenced by this TupleInst.
    mutating func getElements() -> swift.OperandValueArrayRef

    /// Return the i'th value referenced by this TupleInst.
    mutating func getElement(_ i: UInt32) -> swift.SILValue
    mutating func getElementIndex(_ operand: UnsafeMutablePointer<swift.Operand>!) -> UInt32
    mutating func getTupleType() -> UnsafeMutablePointer<swift.TupleType>!

    /// Search the operands of this tuple for a unique non-trivial elt. If we find
    /// it, return it. Otherwise return SILValue().
    mutating func getUniqueNonTrivialElt() -> swift.SILValue
  }

  /// Represents a loadable enum constructed from one of its
  /// elements.
  struct EnumInst {
    mutating func getElement() -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func hasOperand() -> Bool
    mutating func getOperand() -> swift.SILValue
    mutating func getOperandRef() -> UnsafeMutablePointer<swift.Operand>
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Unsafely project the data for an enum case out of an enum without checking
  /// the tag.
  struct UncheckedEnumDataInst {
    mutating func getElement() -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func getEnumDecl() -> UnsafeMutablePointer<swift.EnumDecl>!
    mutating func getElementNo() -> UInt32
  }

  /// Projects the address of the data for a case inside an uninitialized enum in
  /// order to initialize the payload for that case.
  struct InitEnumDataAddrInst {
    mutating func getElement() -> UnsafeMutablePointer<swift.EnumElementDecl>!
  }

  /// InjectEnumAddrInst - Tags an enum as containing a case. The data for
  /// that case, if any, must have been written into the enum first.
  struct InjectEnumAddrInst {
    mutating func getElement() -> UnsafeMutablePointer<swift.EnumElementDecl>!
  }

  /// Invalidate an enum value and take ownership of its payload data
  /// without moving it in memory.
  struct UncheckedTakeEnumDataAddrInst {
    mutating func getElement() -> UnsafeMutablePointer<swift.EnumElementDecl>!
    mutating func getEnumDecl() -> UnsafeMutablePointer<swift.EnumDecl>!
    mutating func getElementNo() -> UInt32
  }
  struct __CxxTemplateInstN5swift14SelectInstBaseINS_15SelectValueInstENS_8SILValueENS_42FirstArgOwnershipForwardingSingleValueInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIN5swift8SILValueES2_EE
    mutating func getNumCases() -> UInt32
    mutating func hasDefault() -> Bool
    mutating func getDefaultResult() -> swift.SILValue
  }
  struct __CxxTemplateInstN5swift14SelectInstBaseINS_18SelectEnumInstBaseEPNS_15EnumElementDeclENS_22SingleValueInstructionEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift15EnumElementDeclENS1_8SILValueEEE
    mutating func getNumCases() -> UInt32
    mutating func hasDefault() -> Bool
    mutating func getDefaultResult() -> swift.SILValue
  }

  /// Common base class for the select_enum and select_enum_addr instructions,
  /// which select one of a set of possible results based on the case of an enum.
  struct SelectEnumInstBase {
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getOperand() -> swift.SILValue
    mutating func getEnumOperand() -> swift.SILValue
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift15EnumElementDeclENS1_8SILValueEEE

    /// Return the value that will be used as the result for the specified enum
    /// case.
    mutating func getCaseResult(_ D: UnsafeMutablePointer<swift.EnumElementDecl>!) -> swift.SILValue

    /// If the default refers to exactly one case decl, return it.
    mutating func getUniqueCaseForDefault() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE
    mutating func hasDefault() -> Bool
    mutating func getDefaultResult() -> swift.SILValue
    mutating func getNumCases() -> UInt32

    /// If there is a single case that returns a literal "true" value (an
    /// "integer_literal $Builtin.Int1, 1" value), return it.
    ///
    /// FIXME: This is used to interoperate with passes that reasoned about the
    /// old enum_is_tag insn. Ideally those passes would become general enough
    /// not to need this.
    mutating func getSingleTrueElement() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE
  }

  /// A select enum inst that produces a static OwnershipKind.
  struct OwnershipForwardingSelectEnumInstBase {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ i: UnsafePointer<swift.SILInstruction>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
  }

  /// Select one of a set of values based on the case of an enum.
  struct SelectEnumInst {
  }

  /// Select one of a set of values based on the case of an enum.
  struct SelectEnumAddrInst {
  }

  /// Select on a value of a builtin integer type.
  ///
  /// There is 'the' operand, followed by pairs of operands for each case,
  /// followed by an optional default operand.
  struct SelectValueInst {
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIN5swift8SILValueES2_EE
    mutating func getNumCases() -> UInt32
    mutating func hasDefault() -> Bool
    mutating func getDefaultResult() -> swift.SILValue
  }

  /// MetatypeInst - Represents the production of an instance of a given metatype
  /// named statically.
  struct MetatypeInst {
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Represents loading a dynamic metatype from a value.
  struct ValueMetatypeInst {
  }

  /// ExistentialMetatype - Represents loading a dynamic metatype from an
  /// existential container.
  struct ExistentialMetatypeInst {
  }

  /// Extract a numbered element out of a value of tuple type.
  struct TupleExtractInst {
    mutating func getFieldIndex() -> UInt32
    mutating func getTupleType() -> UnsafeMutablePointer<swift.TupleType>!
    mutating func getNumTupleElts() -> UInt32

    /// Returns true if this is a trivial result of a tuple that is non-trivial
    /// and represents one RCID.
    mutating func isTrivialEltOfOneRCIDTuple() -> Bool
    mutating func isEltOnlyNonTrivialElt() -> Bool
  }

  /// Derive the address of a numbered element from the address of a tuple.
  struct TupleElementAddrInst {
    mutating func getFieldIndex() -> UInt32
    mutating func getTupleType() -> UnsafeMutablePointer<swift.TupleType>!
  }

  /// Get a unique index for a struct or class field in layout order.
  ///
  /// Precondition: \p decl must be a non-resilient struct or class.
  ///
  /// Precondition: \p field must be a stored property declared in \p decl,
  ///               not in a superclass.
  ///
  /// Postcondition: The returned index is unique across all properties in the
  ///                object, including properties declared in a superclass.
  static func getFieldIndex(_ decl: UnsafeMutablePointer<swift.NominalTypeDecl>!, _ property: UnsafeMutablePointer<swift.VarDecl>!) -> UInt32

  /// Get the property for a struct or class by its unique index, or nullptr if
  /// the index does not match a property declared in this struct or class or
  /// one its superclasses.
  ///
  /// Precondition: \p decl must be a non-resilient struct or class.
  static func getIndexedField(_ decl: UnsafeMutablePointer<swift.NominalTypeDecl>!, _ index: UInt32) -> UnsafeMutablePointer<swift.VarDecl>!

  /// A common base for instructions that require a cached field index.
  ///
  /// "Field" is a term used here to refer to the ordered, accessible stored
  /// properties of a class or struct.
  ///
  /// The field's ordinal value is the basis of efficiently comparing and sorting
  /// access paths in SIL. For example, whenever a Projection object is created,
  /// it stores the field index. Finding the field index initially requires
  /// searching the type declaration's array of all stored properties. If this
  /// index is not cached, it will cause widespread quadratic complexity in any
  /// pass that queries projections, including the SIL verifier.
  ///
  /// FIXME: This cache may not be necessary if the Decl TypeChecker instead
  /// caches a field index in the VarDecl itself. This solution would be superior
  /// because it would allow constant time lookup of either the VarDecl or the
  /// index from a single pointer without referring back to a projection
  /// instruction.
  struct __CxxTemplateInstN5swift19FieldIndexCacheBaseINS_43GuaranteedFirstArgForwardingSingleValueInstEEE {
    mutating func getField() -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getFieldIndex() -> UInt32
    mutating func getParentDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// A common base for instructions that require a cached field index.
  ///
  /// "Field" is a term used here to refer to the ordered, accessible stored
  /// properties of a class or struct.
  ///
  /// The field's ordinal value is the basis of efficiently comparing and sorting
  /// access paths in SIL. For example, whenever a Projection object is created,
  /// it stores the field index. Finding the field index initially requires
  /// searching the type declaration's array of all stored properties. If this
  /// index is not cached, it will cause widespread quadratic complexity in any
  /// pass that queries projections, including the SIL verifier.
  ///
  /// FIXME: This cache may not be necessary if the Decl TypeChecker instead
  /// caches a field index in the VarDecl itself. This solution would be superior
  /// because it would allow constant time lookup of either the VarDecl or the
  /// index from a single pointer without referring back to a projection
  /// instruction.
  struct __CxxTemplateInstN5swift19FieldIndexCacheBaseINS_22SingleValueInstructionEEE {
    mutating func getField() -> UnsafeMutablePointer<swift.VarDecl>!
    mutating func getFieldIndex() -> UInt32
    mutating func getParentDecl() -> UnsafeMutablePointer<swift.NominalTypeDecl>!
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Extract a physical, fragile field out of a value of struct type.
  struct StructExtractInst {
    mutating func getStructDecl() -> UnsafeMutablePointer<swift.StructDecl>!

    /// Returns true if this is a trivial result of a struct that is non-trivial
    /// and represents one RCID.
    mutating func isTrivialFieldOfOneRCIDStruct() -> Bool

    /// Return true if we are extracting the only non-trivial field of out parent
    /// struct. This implies that a ref count operation on the aggregate is
    /// equivalent to a ref count operation on this field.
    mutating func isFieldOnlyNonTrivialField() -> Bool
  }

  /// Derive the address of a physical field from the address of a struct.
  struct StructElementAddrInst {
    mutating func getStructDecl() -> UnsafeMutablePointer<swift.StructDecl>!
  }

  /// RefElementAddrInst - Derive the address of a named element in a reference
  /// type instance.
  struct RefElementAddrInst {
    mutating func getClassDecl() -> UnsafeMutablePointer<swift.ClassDecl>!

    /// Returns true if all loads of the same instance variable from the same
    /// class reference operand are guaranteed to yield the same value.
    mutating func isImmutable() -> Bool

    /// Sets the immutable flag.
    mutating func setImmutable(_ immutable: Bool)
  }

  /// RefTailAddrInst - Derive the address of the first element of the first
  /// tail-allocated array in a reference type instance.
  struct RefTailAddrInst {
    mutating func getClassDecl() -> UnsafeMutablePointer<swift.ClassDecl>!
    mutating func getTailType() -> swift.SILType

    /// Returns true if all loads of the same instance variable from the same
    /// class reference operand are guaranteed to yield the same value.
    mutating func isImmutable() -> Bool

    /// Sets the immutable flag.
    mutating func setImmutable(_ immutable: Bool)
  }

  /// MethodInst - Abstract base for instructions that implement dynamic
  /// method lookup.
  struct MethodInst {
    init(_ Kind: swift.SILInstructionKind, _ DebugLoc: swift.SILDebugLocation, _ Ty: swift.SILType, _ Member: swift.SILDeclRef)
    mutating func getMember() -> swift.SILDeclRef
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }

  /// ClassMethodInst - Given the address of a value of class type and a method
  /// constant, extracts the implementation of that method for the dynamic
  /// instance type of the class.
  struct ClassMethodInst {
  }

  /// SuperMethodInst - Given the address of a value of class type and a method
  /// constant, extracts the implementation of that method for the superclass of
  /// the static type of the class.
  struct SuperMethodInst {
  }

  /// ObjCMethodInst - Given the address of a value of class type and a method
  /// constant, extracts the implementation of that method for the dynamic
  /// instance type of the class.
  struct ObjCMethodInst {
  }

  /// ObjCSuperMethodInst - Given the address of a value of class type and a method
  /// constant, extracts the implementation of that method for the superclass of
  /// the static type of the class.
  struct ObjCSuperMethodInst {
  }

  /// WitnessMethodInst - Given a type, a protocol conformance,
  /// and a protocol method constant, extracts the implementation of that method
  /// for the type.
  struct WitnessMethodInst {
    mutating func getLookupType() -> swift.CanType
    mutating func getLookupProtocol() -> UnsafeMutablePointer<swift.ProtocolDecl>!
    mutating func getConformance() -> swift.ProtocolConformanceRef
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Access allowed to the opened value by the open_existential_addr instruction.
  /// Allowing mutable access to the opened existential requires a boxed
  /// existential value's box to be unique.
  enum OpenedExistentialAccess : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case Immutable
    case Mutable
  }
  static func getOpenedExistentialAccessFor(_ access: swift.AccessKind) -> swift.OpenedExistentialAccess

  /// Given the address of an existential, "opens" the
  /// existential by returning a pointer to a fresh archetype T, which also
  /// captures the (dynamic) conformances.
  struct OpenExistentialAddrInst {
    mutating func getAccessKind() -> swift.OpenedExistentialAccess
  }

  /// Given an opaque value referring to an existential, "opens" the
  /// existential by returning a pointer to a fresh archetype T, which also
  /// captures the (dynamic) conformances.
  struct OpenExistentialValueInst {
  }

  /// Given a class existential, "opens" the
  /// existential by returning a pointer to a fresh archetype T, which also
  /// captures the (dynamic) conformances.
  struct OpenExistentialRefInst {
  }

  /// Given an existential metatype,
  /// "opens" the existential by returning a pointer to a fresh
  /// archetype metatype T.Type, which also captures the (dynamic)
  /// conformances.
  struct OpenExistentialMetatypeInst {
  }

  /// Given a boxed existential container,
  /// "opens" the existential by returning a pointer to a fresh
  /// archetype T, which also captures the (dynamic) conformances.
  struct OpenExistentialBoxInst {
  }

  /// Given a boxed existential container, "opens" the existential by returning a
  /// fresh archetype T, which also captures the (dynamic) conformances.
  struct OpenExistentialBoxValueInst {
  }

  /// Given an address to an uninitialized buffer of
  /// a protocol type, initializes its existential container to contain a concrete
  /// value of the given type, and returns the address of the uninitialized
  /// concrete value inside the existential container.
  struct InitExistentialAddrInst {
    mutating func getConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE
    mutating func getFormalConcreteType() -> swift.CanType
    mutating func getLoweredConcreteType() -> swift.SILType
  }

  /// Given an uninitialized buffer of a protocol type,
  /// initializes its existential container to contain a concrete
  /// value of the given type, and returns the uninitialized
  /// concrete value inside the existential container.
  struct InitExistentialValueInst {
    mutating func getFormalConcreteType() -> swift.CanType
    mutating func getConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE
  }

  /// InitExistentialRefInst - Given a class instance reference and a set of
  /// conformances, creates a class existential value referencing the
  /// class instance.
  struct InitExistentialRefInst {
    mutating func getFormalConcreteType() -> swift.CanType
    mutating func getConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE
  }

  /// InitExistentialMetatypeInst - Given a metatype reference and a set
  /// of conformances, creates an existential metatype value referencing
  /// the metatype.
  struct InitExistentialMetatypeInst {

    /// Return the object type which was erased.  That is, if this
    /// instruction erases Decoder<T>.Type.Type to Printable.Type.Type,
    /// this method returns Decoder<T>.
    mutating func getFormalErasedObjectType() -> swift.CanType
    mutating func getConformances() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift22ProtocolConformanceRefEEE
  }

  /// DeinitExistentialAddrInst - Given an address of an existential that has been
  /// partially initialized with an InitExistentialAddrInst but whose value buffer
  /// has not been initialized, deinitializes the existential and deallocates
  /// the value buffer. This should only be used for partially-initialized
  /// existentials; a fully-initialized existential can be destroyed with
  /// DestroyAddrInst and deallocated with DeallocStackInst.
  struct DeinitExistentialAddrInst {
  }
  struct DeinitExistentialValueInst {
  }

  /// Projects the capture storage address from a @block_storage address.
  struct ProjectBlockStorageInst {
  }

  /// Initializes a block header, creating a block that
  /// invokes a given thin cdecl function.
  struct InitBlockStorageHeaderInst {

    /// Get the block storage address to be initialized.
    mutating func getBlockStorage() -> swift.SILValue

    /// Get the invoke function to form the block around.
    mutating func getInvokeFunction() -> swift.SILValue
    mutating func getSubstitutions() -> swift.SubstitutionMap
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// StrongRetainInst - Increase the strong reference count of an object.
  struct StrongRetainInst {
  }

  /// StrongReleaseInst - Decrease the strong reference count of an object.
  ///
  /// An object can be destroyed when its strong reference count is
  /// zero.  It can be deallocated when both its strong reference and
  /// weak reference counts reach zero.
  struct StrongReleaseInst {
  }
  struct StrongRetainUnownedInst {
  }
  struct UnownedRetainInst {
  }
  struct UnownedReleaseInst {
  }

  /// FixLifetimeInst - An artificial use of a value for the purposes of ARC or
  /// RVO optimizations.
  struct FixLifetimeInst {
  }

  /// EndLifetimeInst - An artificial end lifetime use of a value for the purpose
  /// of working around verification problems.
  ///
  /// Specifically, the signature of destroying deinit takes self at +0 and
  /// returns self at +1. This is an issue since a deallocating deinit takes in
  /// self at +1. Previously, we could rely on the deallocating bit being set in
  /// the object header to allow SILGen to statically balance the +1 from the
  /// deallocating deinit. This is because deallocating values used to be
  /// immortal. The runtime now asserts if we release a deallocating value,
  /// meaning such an approach does not work. This instruction acts as a "fake"
  /// lifetime ending use allowing for static verification of deallocating
  /// destroyers, without an actual release being emitted (avoiding the runtime
  /// assert).
  struct EndLifetimeInst {
  }

  /// An unsafe conversion in between ownership kinds.
  ///
  /// This is used today in destructors where due to Objective-C legacy
  /// constraints, we need to be able to convert a guaranteed parameter to an owned
  /// parameter.
  struct UncheckedOwnershipConversionInst {
    mutating func getConversionOwnershipKind() -> swift.ValueOwnershipKind
  }

  /// Indicates that the validity of the first operand ("the value") depends on
  /// the value of the second operand ("the base").  Operations that would destroy
  /// the base must not be moved before any instructions which depend on the
  /// result of this instruction, exactly as if the address had been obviously
  /// derived from that operand (e.g. using ``ref_element_addr``). The result is
  /// always equal to the first operand and thus forwards ownership through the
  /// first operand. This is a "regular" use of the second operand (i.e. the
  /// second operand must be live at the use point).
  ///
  /// Example:
  ///
  ///   %base = ...
  ///   %value = ... @trivial value ...
  ///   %value_dependent_on_base = mark_dependence %value on %base
  ///   ...
  ///   use(%value_dependent_on_base)     (1)
  ///   ...
  ///   destroy_value %base               (2)
  ///
  /// (2) can never move before (1). In English this is a way for the compiler
  /// writer to say to the optimizer: 'This subset of uses of "value" (the uses of
  /// result) have a dependence on "base" being alive. Do not allow for things
  /// that /may/ destroy base to be moved earlier than any of these uses of
  /// "value"'.
  struct MarkDependenceInst {
    mutating func getValue() -> swift.SILValue
    mutating func getBase() -> swift.SILValue
    mutating func setValue(_ newVal: swift.SILValue)
    mutating func setBase(_ newVal: swift.SILValue)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Promote an Objective-C block that is on the stack to the heap, or simply
  /// retain a block that is already on the heap.
  struct CopyBlockInst {
  }
  struct CopyBlockWithoutEscapingInst {
    mutating func getBlock() -> swift.SILValue
    mutating func getClosure() -> swift.SILValue
    mutating func setBlock(_ block: swift.SILValue)
    mutating func setClosure(_ closure: swift.SILValue)
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }
  struct CopyValueInst {
  }
  struct StrongCopyUnownedValueInst {
  }
  struct StrongCopyUnmanagedValueInst {
  }
  struct DestroyValueInst {
  }

  /// Given an object reference, return true iff it is non-nil and refers
  /// to a native swift object with strong reference count of 1.
  struct IsUniqueInst {
  }

  /// Performs a uniqueness check of the operand for the purpose of modifying
  /// a copy-on-write object.
  ///
  /// Returns two results: the first result is an Int1 which is the result of the
  /// uniqueness check. The second result is the class reference operand, which
  /// can be used for mutation.
  struct BeginCOWMutationInst {

    /// Returns the result of the uniqueness check.
    mutating func getUniquenessResult() -> swift.SILValue

    /// Returns the class reference which can be used for mutation.
    mutating func getBufferResult() -> swift.SILValue
    mutating func isNative() -> Bool
    mutating func setNative(_ native: Bool)
  }

  /// A result for the begin_cow_mutation instruction. See documentation for
  /// begin_cow_mutation for more information.
  struct BeginCOWMutationResult {
    init(_ index: UInt32, _ type: swift.SILType, _ ownershipKind: swift.ValueOwnershipKind)
    mutating func getParent() -> UnsafeMutablePointer<swift.BeginCOWMutationInst>!
    mutating func getParent() -> UnsafePointer<swift.BeginCOWMutationInst>!
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Marks the end of the mutation of a reference counted object.
  struct EndCOWMutationInst {
    mutating func doKeepUnique() -> Bool
    mutating func setKeepUnique(_ keepUnique: Bool)
  }

  /// Given an escaping closure return true iff it has a non-nil context and the
  /// context has a strong reference count greater than 1.
  struct IsEscapingClosureInst {
    mutating func getVerificationType() -> UInt32
  }

  /// DeallocationInst - An abstract parent class for Dealloc{Stack, Box, Ref}.
  struct DeallocationInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }

  /// Deallocate memory for a reference type instance from a destructor or
  /// failure path of a constructor.
  ///
  /// This does not destroy the referenced instance; it must be destroyed
  /// first.
  ///
  /// It is undefined behavior if the type of the operand does not match the
  /// most derived type of the allocated instance.
  struct DeallocRefInst {
    mutating func canAllocOnStack() -> Bool
    mutating func setStackAllocatable(_ OnStack: Bool)
  }

  /// Deallocate memory for a reference type instance from a failure path of a
  /// constructor.
  ///
  /// The instance is assumed to have been partially initialized, with the
  /// initialized portion being all instance variables in classes that are more
  /// derived than the given metatype.
  ///
  /// The metatype value can either be the static self type (in a designated
  /// initializer) or a dynamic self type (in a convenience initializer).
  struct DeallocPartialRefInst {
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getInstance() -> swift.SILValue
    mutating func getMetatype() -> swift.SILValue
  }

  /// Deallocate memory allocated for an unsafe value buffer.
  struct DeallocValueBufferInst {
    mutating func getValueType() -> swift.SILType
  }

  /// Deallocate memory allocated for a boxed value created by an AllocBoxInst.
  /// It is undefined behavior if the type of the boxed type does not match the
  /// type the box was allocated for.
  ///
  /// This does not destroy the boxed value instance; it must either be
  /// uninitialized or have been manually destroyed.
  struct DeallocBoxInst {
  }

  /// Deallocate memory allocated for a boxed existential container created by
  /// AllocExistentialBox. It is undefined behavior if the given concrete type
  /// does not match the concrete type for which the box was allocated.
  ///
  /// This does not destroy the boxed value instance; it must either be
  /// uninitialized or have been manually destroyed.
  struct DeallocExistentialBoxInst {
    mutating func getConcreteType() -> swift.CanType
  }

  /// Destroy the value at a memory location according to
  /// its SIL type. This is similar to:
  ///   %1 = load %operand
  ///   release_value %1
  /// but a destroy instruction can be used for types that cannot be loaded,
  /// such as resilient value types.
  struct DestroyAddrInst {
  }

  /// Project out the address of the value
  /// stored in the given Builtin.UnsafeValueBuffer.
  struct ProjectValueBufferInst {
    mutating func getValueType() -> swift.SILType
  }

  /// Project out the address of the value in a box.
  struct ProjectBoxInst {
    mutating func getFieldIndex() -> UInt32
  }

  /// Project out the address of the value in an existential box.
  struct ProjectExistentialBoxInst {
  }

  /// Trigger a runtime failure if the given Int1 value is true.
  ///
  /// Optionally cond_fail has a static failure message, which is displayed in the debugger in case the failure
  /// is triggered.
  struct CondFailInst {
    mutating func getMessage() -> llvm.StringRef
  }

  /// Abstract base class for indexing instructions.
  struct IndexingInst {
    init(_ Kind: swift.SILInstructionKind, _ DebugLoc: swift.SILDebugLocation, _ ResultTy: swift.SILType, _ Operand: swift.SILValue, _ Index: swift.SILValue)
    mutating func getBase() -> swift.SILValue
    mutating func getIndex() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SingleValueInstruction>!) -> Bool
  }

  /// IndexAddrInst - "%2 : $*T = index_addr %0 : $*T, %1 : $Builtin.Word"
  /// This takes an address and indexes it, striding by the pointed-
  /// to type.  This is used to index into arrays of uniform elements.
  struct IndexAddrInst {
  }

  /// TailAddrInst - like IndexingInst, but aligns-up the resulting address to a
  /// tail-allocated element type.
  struct TailAddrInst {
    mutating func getTailType() -> swift.SILType
  }

  /// IndexRawPointerInst
  /// %2 : $Builtin.RawPointer \
  ///   = index_raw_pointer %0 : $Builtin.RawPointer, %1 : $Builtin.Word
  /// This takes an address and indexes it, striding by the pointed-
  /// to type.  This is used to index into arrays of uniform elements.
  struct IndexRawPointerInst {
  }
  enum TermKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case UnreachableInst
    case ReturnInst
    case ThrowInst
    case YieldInst
    case UnwindInst
    case TryApplyInst
    case BranchInst
    case CondBranchInst
    case SwitchValueInst
    case SwitchEnumInst
    case SwitchEnumAddrInst
    case DynamicMethodBranchInst
    case AwaitAsyncContinuationInst
    case CheckedCastBranchInst
    case CheckedCastAddrBranchInst
    case CheckedCastValueBranchInst
  }

  /// This class defines a "terminating instruction" for a SILBasicBlock.
  struct TermInst {
    typealias ConstSuccessorListTy = llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift12SILSuccessorEEE
    typealias SuccessorListTy = llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift12SILSuccessorEEE
    typealias const_succ_iterator = llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift12SILSuccessorEEE.const_iterator
    typealias succ_iterator = llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift12SILSuccessorEEE.iterator
    typealias succblock_iterator = swift.__CxxTemplateInstN5swift17TransformIteratorIPNS_12SILSuccessorEPFPNS_13SILBasicBlockERKS1_EEE
    typealias const_succblock_iterator = swift.__CxxTemplateInstN5swift17TransformIteratorIPKNS_12SILSuccessorEPFPKNS_13SILBasicBlockERS2_EEE
    typealias SuccessorBlockListTy = swift.__CxxTemplateInstN5swift14TransformRangeIN4llvm15MutableArrayRefINS_12SILSuccessorEEEPFPNS_13SILBasicBlockERKS3_EEE
    typealias ConstSuccessorBlockListTy = swift.__CxxTemplateInstN5swift14TransformRangeIN4llvm8ArrayRefINS_12SILSuccessorEEEPFPKNS_13SILBasicBlockERKS3_EEE

    /// The successor basic blocks of this terminator.
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getSuccessors() -> swift.TermInst.ConstSuccessorListTy
    mutating func succ_empty() -> Bool
    mutating func succ_begin() -> swift.TermInst.succ_iterator!
    mutating func succ_end() -> swift.TermInst.succ_iterator!
    mutating func succ_begin() -> swift.TermInst.const_succ_iterator!
    mutating func succ_end() -> swift.TermInst.const_succ_iterator!
    mutating func getNumSuccessors() -> UInt32
    mutating func succblock_begin() -> swift.TermInst.succblock_iterator
    mutating func succblock_end() -> swift.TermInst.succblock_iterator
    mutating func succblock_begin() -> swift.TermInst.const_succblock_iterator
    mutating func succblock_end() -> swift.TermInst.const_succblock_iterator
    mutating func getSingleSuccessorBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSingleSuccessorBlock() -> UnsafePointer<swift.SILBasicBlock>!

    /// Returns true if \p BB is a successor of this block.
    mutating func isSuccessorBlock(_ BB: UnsafeMutablePointer<swift.SILBasicBlock>!) -> Bool

    /// Return the range of SILBasicBlocks that are successors of this block.
    mutating func getSuccessorBlocks() -> swift.TermInst.SuccessorBlockListTy

    /// Return the range of SILBasicBlocks that are successors of this block.
    mutating func getSuccessorBlocks() -> swift.TermInst.ConstSuccessorBlockListTy
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    mutating func isBranch() -> Bool

    /// Returns true if this terminator exits the function.
    mutating func isFunctionExiting() -> Bool

    /// Returns true if this terminator terminates the program.
    mutating func isProgramTerminating() -> Bool
    mutating func getTermKind() -> swift.TermKind

    /// Returns true if this is a transformation terminator.
    mutating func isTransformationTerminator() -> Bool
  }
  struct OwnershipForwardingTermInst {
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ inst: UnsafePointer<swift.SILInstruction>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
  }

  /// UnreachableInst - Position in the code which would be undefined to reach.
  /// These are always implicitly generated, e.g. when falling off the end of a
  /// function or after a no-return function call.
  struct UnreachableInst {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// ReturnInst - Representation of a ReturnStmt.
  struct ReturnInst {

    /// Return the ownership kind for this instruction if we had any direct
    /// results.
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
  }

  /// ThrowInst - Throw a typed error (which, in our system, is
  /// essentially just a funny kind of return).
  struct ThrowInst {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
  }

  /// UnwindInst - Continue unwinding out of this function.  Currently this is
  /// only used in coroutines as the eventual terminator of the unwind edge
  /// out of a 'yield'.
  struct UnwindInst {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// Suspend execution of an async task until
  /// essentially just a funny kind of return).
  struct AwaitAsyncContinuationInst {

    /// Returns the basic block to which control is transferred when the task is
    /// resumed normally.
    ///
    /// This basic block should take an argument of the continuation's resume type,
    /// unless the continuation is formed by a \c GetAsyncContinuationAddrInst
    /// that binds a specific memory location to receive the resume value.
    mutating func getResumeBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Returns the basic block to which control is transferred when the task is
    /// resumed in an error state, or `nullptr` if the continuation does not support
    /// failure.
    ///
    /// This basic block should take an argument of Error type.
    mutating func getErrorBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
  }

  /// YieldInst - Yield control temporarily to the caller of this coroutine.
  ///
  /// This is a terminator because the caller can abort the coroutine,
  /// e.g. if an error is thrown and an unwind is provoked.
  struct YieldInst {

    /// Return the normal resume destination of the yield, which is where the
    /// coroutine resumes when the caller is ready to continue normally.
    ///
    /// This must be the unique predecessor edge of the given block.
    ///
    /// Control flow along every path from this block must either loop or
    /// eventually terminate in a 'return', 'throw', or 'unreachable'
    /// instruction.  In a yield_many coroutine, control is permitted to
    /// first reach a 'yield' instruction; this is prohibited in a
    /// yield_once coroutine.
    mutating func getResumeBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// Return the 'unwind' destination of the yield, which is where the
    /// coroutine resumes when the caller is unconditionally aborting the
    /// coroutine.
    ///
    /// This must be the unique predecessor edge of the given block.
    ///
    /// Control flow along every path from this block must either loop or
    /// eventually terminate in an 'unwind' or 'unreachable' instruction.
    /// It is not permitted to reach a 'yield' instruction.
    mutating func getUnwindBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getYieldedValues() -> swift.OperandValueArrayRef
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getYieldInfoForOperand(_ op: UnsafePointer<swift.Operand>) -> swift.SILYieldInfo
    mutating func getArgumentConventionForOperand(_ op: UnsafePointer<swift.Operand>) -> swift.SILArgumentConvention
  }

  /// BranchInst - An unconditional branch.
  struct BranchInst {

    /// returns jump target for the branch.
    mutating func getDestBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// The arguments for the destination BB.
    mutating func getArgs() -> swift.OperandValueArrayRef
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getNumArgs() -> UInt32
    mutating func getArg(_ i: UInt32) -> swift.SILValue

    /// Return the SILPhiArgument for the given operand.
    mutating func getArgForOperand(_ oper: UnsafePointer<swift.Operand>!) -> UnsafePointer<swift.SILPhiArgument>!

    /// Return the SILPhiArgument for the given operand.
    ///
    /// See SILArgument.cpp.
    mutating func getArgForOperand(_ oper: UnsafePointer<swift.Operand>!) -> UnsafeMutablePointer<swift.SILPhiArgument>!
  }

  /// A conditional branch.
  struct CondBranchInst {
    mutating func getConditionOperand() -> UnsafePointer<swift.Operand>!
    mutating func getCondition() -> swift.SILValue
    mutating func setCondition(_ newCondition: swift.SILValue)
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getTrueBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getTrueBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getFalseBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getFalseBB() -> UnsafePointer<swift.SILBasicBlock>!

    /// The number of times the True branch was executed.
    mutating func getTrueBBCount() -> swift.ProfileCounter

    /// The number of times the False branch was executed.
    mutating func getFalseBBCount() -> swift.ProfileCounter

    /// Get the arguments to the true BB.
    mutating func getTrueArgs() -> swift.OperandValueArrayRef

    /// Get the arguments to the false BB.
    mutating func getFalseArgs() -> swift.OperandValueArrayRef

    /// Get the operands to the true BB.
    mutating func getTrueOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTrueOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Get the operands to the false BB.
    mutating func getFalseOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getFalseOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE

    /// Returns true if \p op is mapped to the condition operand of the cond_br.
    mutating func isConditionOperand(_ op: UnsafeMutablePointer<swift.Operand>!) -> Bool
    mutating func isConditionOperandIndex(_ OpIndex: UInt32) -> Bool

    /// Is \p OpIndex an operand associated with the true case?
    mutating func isTrueOperandIndex(_ OpIndex: UInt32) -> Bool

    /// Is \p OpIndex an operand associated with the false case?
    mutating func isFalseOperandIndex(_ OpIndex: UInt32) -> Bool

    /// Returns the operand on the cond_br terminator associated with the value
    /// that will be passed to DestBB in A.
    mutating func getOperandForDestBB(_ DestBB: UnsafePointer<swift.SILBasicBlock>!, _ A: UnsafePointer<swift.SILArgument>!) -> UnsafeMutablePointer<swift.Operand>!

    /// Returns the operand on the cond_br terminator associated with the value
    /// that will be passed as the \p Index argument to DestBB.
    mutating func getOperandForDestBB(_ DestBB: UnsafePointer<swift.SILBasicBlock>!, _ ArgIndex: UInt32) -> UnsafeMutablePointer<swift.Operand>!

    /// Returns the argument on the cond_br terminator that will be passed to
    /// DestBB in A.
    mutating func getArgForDestBB(_ DestBB: UnsafePointer<swift.SILBasicBlock>!, _ A: UnsafePointer<swift.SILArgument>!) -> swift.SILValue

    /// Returns the argument on the cond_br terminator that will be passed as the
    /// \p Index argument to DestBB.
    mutating func getArgForDestBB(_ DestBB: UnsafePointer<swift.SILBasicBlock>!, _ ArgIndex: UInt32) -> swift.SILValue

    /// Return the SILPhiArgument from either the true or false destination for
    /// the given operand.
    ///
    /// Returns nullptr for an operand with no block argument
    /// (i.e the branch condition).
    ///
    /// See SILArgument.cpp.
    mutating func getArgForOperand(_ oper: UnsafePointer<swift.Operand>!) -> UnsafePointer<swift.SILPhiArgument>!
    mutating func swapSuccessors()
  }

  /// A switch on a value of a builtin type.
  struct SwitchValueInst {
    mutating func getOperand() -> swift.SILValue
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getNumCases() -> UInt32
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIN5swift8SILValueEPNS1_13SILBasicBlockEEE
    mutating func hasDefault() -> Bool
    mutating func getDefaultBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getUniqueCaseForDestination(_ bb: UnsafeMutablePointer<swift.SILBasicBlock>!) -> llvm.__CxxTemplateInstN4llvm8OptionalIjEE
  }

  /// Common implementation for the switch_enum and switch_enum_addr instructions.
  struct __CxxTemplateInstN5swift18SwitchEnumInstBaseINS_27OwnershipForwardingTermInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getNumCases() -> UInt32
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift15EnumElementDeclEPNS1_13SILBasicBlockEEE
    mutating func getCaseCount(_ i: UInt32) -> swift.ProfileCounter
    mutating func swapCase(_ i: UInt32, _ j: UInt32)

    /// Return the block that will be branched to on the specified enum
    /// case.
    mutating func getCaseDestination(_ D: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// If the default refers to exactly one case decl, return it.
    mutating func getUniqueCaseForDefault() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE

    /// If the given block only has one enum element decl matched to it,
    /// return it.
    mutating func getUniqueCaseForDestination(_ block: UnsafeMutablePointer<swift.SILBasicBlock>!) -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE
    mutating func hasDefault() -> Bool
    mutating func getDefaultBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getDefaultBBOrNull() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE
    mutating func getDefaultCount() -> swift.ProfileCounter
    static func classof(_ I: UnsafePointer<swift.SILInstruction>!) -> Bool
  }

  /// Common implementation for the switch_enum and switch_enum_addr instructions.
  struct __CxxTemplateInstN5swift18SwitchEnumInstBaseINS_8TermInstEEE {
    mutating func getOperand() -> swift.SILValue
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getNumCases() -> UInt32
    mutating func getCase(_ i: UInt32) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift15EnumElementDeclEPNS1_13SILBasicBlockEEE
    mutating func getCaseCount(_ i: UInt32) -> swift.ProfileCounter
    mutating func swapCase(_ i: UInt32, _ j: UInt32)

    /// Return the block that will be branched to on the specified enum
    /// case.
    mutating func getCaseDestination(_ D: UnsafeMutablePointer<swift.EnumElementDecl>!) -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// If the default refers to exactly one case decl, return it.
    mutating func getUniqueCaseForDefault() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE

    /// If the given block only has one enum element decl matched to it,
    /// return it.
    mutating func getUniqueCaseForDestination(_ block: UnsafeMutablePointer<swift.SILBasicBlock>!) -> swift.__CxxTemplateInstN5swift11NullablePtrINS_15EnumElementDeclEEE
    mutating func hasDefault() -> Bool
    mutating func getDefaultBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getDefaultBBOrNull() -> swift.__CxxTemplateInstN5swift11NullablePtrINS_13SILBasicBlockEEE
    mutating func getDefaultCount() -> swift.ProfileCounter
    static func classof(_ I: UnsafePointer<swift.SILInstruction>!) -> Bool
  }

  /// A switch on a loadable enum's discriminator. The data for each case is
  /// passed into the corresponding destination block as an argument.
  struct SwitchEnumInst {
  }

  /// A switch on an enum's discriminator in memory.
  struct SwitchEnumAddrInst {
  }

  /// Branch on the existence of an Objective-C method in the dynamic type of
  /// an object.
  ///
  /// If the method exists, branches to the first BB, providing it with the
  /// method reference; otherwise, branches to the second BB.
  struct DynamicMethodBranchInst {
    mutating func getOperand() -> swift.SILValue
    mutating func getMember() -> swift.SILDeclRef
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getHasMethodBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getHasMethodBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getNoMethodBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getNoMethodBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }

  /// The base class for cast instructions which are terminators.
  struct __CxxTemplateInstN5swift18CastBranchInstBaseINS_27OwnershipForwardingTermInstEEE {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getSuccessBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSuccessBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getFailureBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getFailureBB() -> UnsafePointer<swift.SILBasicBlock>!

    /// The number of times the True branch was executed
    mutating func getTrueBBCount() -> swift.ProfileCounter

    /// The number of times the False branch was executed
    mutating func getFalseBBCount() -> swift.ProfileCounter
  }

  /// The base class for cast instructions which are terminators.
  struct __CxxTemplateInstN5swift18CastBranchInstBaseINS_8TermInstEEE {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func getSuccessBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getSuccessBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getFailureBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getFailureBB() -> UnsafePointer<swift.SILBasicBlock>!

    /// The number of times the True branch was executed
    mutating func getTrueBBCount() -> swift.ProfileCounter

    /// The number of times the False branch was executed
    mutating func getFalseBBCount() -> swift.ProfileCounter
  }

  /// The base class for cast instructions which are terminators and have a
  /// CastConsumptionKind.
  struct CastBranchWithConsumptionKindBase {
    init(_ K: swift.SILInstructionKind, _ DebugLoc: swift.SILDebugLocation, _ consumptionKind: swift.CastConsumptionKind, _ SuccessBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ FailureBB: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Target1Count: swift.ProfileCounter, _ Target2Count: swift.ProfileCounter)
    mutating func getConsumptionKind() -> swift.CastConsumptionKind
  }

  /// Helper base class for AddrCastInstBase.
  ///
  /// Ideally, the types would just be a member of AddrCastInstBase. But because
  /// of tail-allocated operands, they need to be in a base class of
  /// InstructionBaseWithTrailingOperands.
  struct __CxxTemplateInstN5swift17TypesForAddrCastsINS_33CastBranchWithConsumptionKindBaseEEE {
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetFormalType() -> swift.CanType
  }

  /// Helper base class for AddrCastInstBase.
  ///
  /// Ideally, the types would just be a member of AddrCastInstBase. But because
  /// of tail-allocated operands, they need to be in a base class of
  /// InstructionBaseWithTrailingOperands.
  struct __CxxTemplateInstN5swift17TypesForAddrCastsINS_19NonValueInstructionEEE {
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetFormalType() -> swift.CanType
  }

  /// Base class for cast instructions with address-type operands.
  struct __CxxTemplateInstN5swift16AddrCastInstBaseILNS_18SILInstructionKindE183ENS_24UncheckedRefCastAddrInstENS_19NonValueInstructionEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getTargetLoweredType() -> swift.SILType
  }

  /// Base class for cast instructions with address-type operands.
  struct __CxxTemplateInstN5swift16AddrCastInstBaseILNS_18SILInstructionKindE138ENS_25CheckedCastAddrBranchInstENS_33CastBranchWithConsumptionKindBaseEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getTargetLoweredType() -> swift.SILType
  }

  /// Base class for cast instructions with address-type operands.
  struct __CxxTemplateInstN5swift16AddrCastInstBaseILNS_18SILInstructionKindE182ENS_32UnconditionalCheckedCastAddrInstENS_19NonValueInstructionEEE {
    mutating func getNumTypeDependentOperands() -> UInt32
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getTypeDependentOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func getSrc() -> swift.SILValue
    mutating func getDest() -> swift.SILValue
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getTargetLoweredType() -> swift.SILType
  }

  /// Perform a checked cast operation and branch on whether the cast succeeds.
  /// The success branch destination block receives the cast result as a BB
  /// argument.
  struct CheckedCastBranchInst {
    mutating func isExact() -> Bool
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetLoweredType() -> swift.SILType
    mutating func getTargetFormalType() -> swift.CanType
  }

  /// Perform a checked cast operation and branch on whether the cast succeeds.
  /// The success branch destination block receives the cast result as a BB
  /// argument.
  struct CheckedCastValueBranchInst {
    mutating func getSourceLoweredType() -> swift.SILType
    mutating func getSourceFormalType() -> swift.CanType
    mutating func getTargetLoweredType() -> swift.SILType
    mutating func getTargetFormalType() -> swift.CanType
  }

  /// Perform a checked cast operation and branch on whether the cast succeeds.
  /// The result of the checked cast is left in the destination address.
  struct CheckedCastAddrBranchInst {
  }

  /// Converts a heap object reference to a different type without any runtime
  /// checks. This is a variant of UncheckedRefCast that works on address types,
  /// thus encapsulates an implicit load and take of the reference followed by a
  /// store and initialization of a new reference.
  struct UncheckedRefCastAddrInst {
    init(_ Loc: swift.SILDebugLocation, _ src: swift.SILValue, _ srcType: swift.CanType, _ dest: swift.SILValue, _ targetType: swift.CanType, _ TypeDependentOperands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE)
    static func create(_ Loc: swift.SILDebugLocation, _ src: swift.SILValue, _ srcType: swift.CanType, _ dest: swift.SILValue, _ targetType: swift.CanType, _ F: UnsafeMutablePointer<swift.SILFunction>, _ OpenedArchetypes: UnsafeMutablePointer<swift.SILOpenedArchetypesState>) -> UnsafeMutablePointer<swift.UncheckedRefCastAddrInst>!
  }
  struct UncheckedAddrCastInst {
  }

  /// Perform an unconditional checked cast that aborts if the cast fails.
  /// The result of the checked cast is left in the destination address.
  struct UnconditionalCheckedCastAddrInst {
  }

  /// A private abstract class to store the destinations of a TryApplyInst.
  struct TryApplyInstBase {
    mutating func getSuccessors() -> swift.TermInst.SuccessorListTy
    mutating func isNormalSuccessorRef(_ successor: UnsafeMutablePointer<swift.SILSuccessor>!) -> Bool
    mutating func isErrorSuccessorRef(_ successor: UnsafeMutablePointer<swift.SILSuccessor>!) -> Bool
    mutating func getNormalBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getNormalBB() -> UnsafePointer<swift.SILBasicBlock>!
    mutating func getErrorBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getErrorBB() -> UnsafePointer<swift.SILBasicBlock>!
  }

  /// TryApplyInst - Represents the full application of a function that
  /// can produce an error.
  struct TryApplyInst {
  }

  /// DifferentiableFunctionInst - creates a `@differentiable` function-typed
  /// value from an original function operand and derivative function operands
  /// (optional). The differentiation transform canonicalizes
  /// `differentiable_function` instructions, filling in derivative function
  /// operands if missing.
  struct DifferentiableFunctionInst {
    static func create(_ Module: UnsafeMutablePointer<swift.SILModule>, _ Loc: swift.SILDebugLocation, _ ParameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ ResultIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ OriginalFunction: swift.SILValue, _ VJPAndJVPFunctions: llvm.__CxxTemplateInstN4llvm8OptionalINSt3__14pairIN5swift8SILValueES4_EEEE, _ HasOwnership: Bool) -> UnsafeMutablePointer<swift.DifferentiableFunctionInst>!

    /// Returns the original function operand.
    mutating func getOriginalFunction() -> swift.SILValue

    /// Returns differentiability parameter indices.
    mutating func getParameterIndices() -> UnsafeMutablePointer<swift.IndexSubset>!

    /// Returns differentiability result indices.
    mutating func getResultIndices() -> UnsafeMutablePointer<swift.IndexSubset>!

    /// Returns true if derivative functions (JVP/VJP) exist.
    mutating func hasDerivativeFunctions() -> Bool

    /// Returns the derivative function operands if they exist.
    /// Otherwise, return `None`.
    mutating func getOptionalDerivativeFunctionPair() -> llvm.__CxxTemplateInstN4llvm8OptionalINSt3__14pairIN5swift8SILValueES4_EEEE
    mutating func getDerivativeFunctionArray() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Returns the JVP function operand.
    mutating func getJVPFunction() -> swift.SILValue

    /// Returns the VJP function operand.
    mutating func getVJPFunction() -> swift.SILValue

    /// Returns the derivative function operand (JVP or VJP) with the given kind.
    mutating func getDerivativeFunction(_ kind: swift.AutoDiffDerivativeFunctionKind) -> swift.SILValue
  }

  /// LinearFunctionInst - given a function, its derivative and traspose functions,
  /// create an `@differentiable(linear)` function that represents a bundle of these.
  struct LinearFunctionInst {
    init(_ Loc: swift.SILDebugLocation, _ ParameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ OriginalFunction: swift.SILValue, _ TransposeFunction: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift8SILValueEEE, _ HasOwnership: Bool)
    static func create(_ Module: UnsafeMutablePointer<swift.SILModule>, _ Loc: swift.SILDebugLocation, _ ParameterIndices: UnsafeMutablePointer<swift.IndexSubset>!, _ OriginalFunction: swift.SILValue, _ TransposeFunction: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift8SILValueEEE, _ HasOwnership: Bool) -> UnsafeMutablePointer<swift.LinearFunctionInst>!
    mutating func getParameterIndices() -> UnsafeMutablePointer<swift.IndexSubset>!
    mutating func hasTransposeFunction() -> Bool
    mutating func getOriginalFunction() -> swift.SILValue
    mutating func getOptionalTransposeFunction() -> llvm.__CxxTemplateInstN4llvm8OptionalIN5swift8SILValueEEE
    mutating func getTransposeFunction() -> swift.SILValue
  }

  /// DifferentiableFunctionExtractInst - extracts either the original or
  /// derivative function value from a `@differentiable` function.
  struct DifferentiableFunctionExtractInst {

    /// Note: explicit extractee type may be specified only in lowered SIL.
    init(_ module: UnsafeMutablePointer<swift.SILModule>, _ debugLoc: swift.SILDebugLocation, _ extractee: swift.NormalDifferentiableFunctionTypeComponent, _ function: swift.SILValue, _ extracteeType: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift7SILTypeEEE)
    mutating func getExtractee() -> swift.NormalDifferentiableFunctionTypeComponent
    mutating func getDerivativeFunctionKind() -> swift.AutoDiffDerivativeFunctionKind
    mutating func hasExplicitExtracteeType() -> Bool
  }

  /// LinearFunctionExtractInst - given an `@differentiable(linear)` function
  /// representing a bundle of the original function and the transpose function,
  /// extract the specified function.
  struct LinearFunctionExtractInst {
    init(_ module: UnsafeMutablePointer<swift.SILModule>, _ debugLoc: swift.SILDebugLocation, _ extractee: swift.LinearDifferentiableFunctionTypeComponent, _ theFunction: swift.SILValue)
    mutating func getExtractee() -> swift.LinearDifferentiableFunctionTypeComponent
  }

  /// DifferentiabilityWitnessFunctionInst - Looks up a differentiability witness
  /// function for a given original function.
  struct DifferentiabilityWitnessFunctionInst {

    /// Note: explicit function type may be specified only in lowered SIL.
    init(_ module: UnsafeMutablePointer<swift.SILModule>, _ loc: swift.SILDebugLocation, _ witnessKind: swift.DifferentiabilityWitnessFunctionKind, _ witness: UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!, _ FunctionType: llvm.__CxxTemplateInstN4llvm8OptionalIN5swift7SILTypeEEE)
    mutating func getWitnessKind() -> swift.DifferentiabilityWitnessFunctionKind
    mutating func getWitness() -> UnsafeMutablePointer<swift.SILDifferentiabilityWitness>!
    mutating func getHasExplicitFunctionType() -> Bool
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE
    mutating func getAllOperands() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
  }
  struct OwnershipForwardingMultipleValueInstruction {
    init(_ kind: swift.SILInstructionKind, _ loc: swift.SILDebugLocation, _ ownershipKind: swift.ValueOwnershipKind)
    static func classof(_ n: UnsafePointer<swift.SILNode>!) -> Bool
    static func classof(_ i: UnsafePointer<swift.SILInstruction>!) -> Bool
    static func classof(_ kind: swift.SILInstructionKind) -> Bool
  }

  /// A result for the destructure_struct instruction. See documentation for
  /// destructure_struct for more information.
  struct DestructureStructResult {
    init(_ Index: UInt32, _ Type: swift.SILType, _ OwnershipKind: swift.ValueOwnershipKind)
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
    mutating func getParent() -> UnsafeMutablePointer<swift.DestructureStructInst>!
    mutating func getParent() -> UnsafePointer<swift.DestructureStructInst>!
  }

  /// A result for the destructure_tuple instruction. See documentation for
  /// destructure_tuple for more information.
  struct DestructureTupleResult {
    init(_ Index: UInt32, _ Type: swift.SILType, _ OwnershipKind: swift.ValueOwnershipKind)
    static func classof(_ N: UnsafePointer<swift.SILNode>!) -> Bool
    mutating func getParent() -> UnsafeMutablePointer<swift.DestructureTupleInst>!
    mutating func getParent() -> UnsafePointer<swift.DestructureTupleInst>!
  }

  /// The name of the standard library, which is a reserved module name.
  static let STDLIB_NAME: llvm.StringLiteral

  /// The name of the Onone support library, which is a reserved module name.
  static let SWIFT_ONONE_SUPPORT: llvm.StringLiteral

  /// The name of the Concurrency module, which supports that extension.
  static let SWIFT_CONCURRENCY_NAME: llvm.StringLiteral

  /// The name of the SwiftShims module, which contains private stdlib decls.
  static let SWIFT_SHIMS_NAME: llvm.StringLiteral

  /// The name of the Builtin module, which contains Builtin functions.
  static let BUILTIN_NAME: llvm.StringLiteral

  /// The name of the clang imported header module.
  static let CLANG_HEADER_MODULE_NAME: llvm.StringLiteral

  /// The prefix of module names used by LLDB to capture Swift expressions
  static let LLDB_EXPRESSIONS_MODULE_NAME_PREFIX: llvm.StringLiteral

  /// The name of the fake module used to hold imported Objective-C things.
  static let MANGLING_MODULE_OBJC: llvm.StringLiteral

  /// The name of the fake module used to hold synthesized ClangImporter things.
  static let MANGLING_MODULE_CLANG_IMPORTER: llvm.StringLiteral

  /// The name prefix for C++ template instantiation imported as a Swift struct.
  static let CXX_TEMPLATE_INST_PREFIX: llvm.StringLiteral
  static let SEMANTICS_PROGRAMTERMINATION_POINT: llvm.StringLiteral
  static let DEFAULT_ACTOR_STORAGE_FIELD_NAME: llvm.StringLiteral

  /// The name of the Builtin type prefix
  static let BUILTIN_TYPE_NAME_PREFIX: llvm.StringLiteral

  /// A composition class containing a StringLiteral for the names of
  /// Swift builtins. The reason we use this is to ensure that we when
  /// necessary slice off the "Builtin." prefix from these names in a
  /// constexpr way from a global constant string.
  ///
  /// NOTE: StringLiteral is a weird class to compose with. For this to
  /// work properly, one must always initialize these classes using an
  /// initializer list as shown below.
  struct BuiltinNameStringLiteral {
    var literal: llvm.StringLiteral { get }
    init(literal: llvm.StringLiteral)
    mutating func getWithoutPrefix() -> llvm.StringRef
  }

  /// The name of the Builtin type for Int
  static let BUILTIN_TYPE_NAME_INT: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int8
  static let BUILTIN_TYPE_NAME_INT8: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int16
  static let BUILTIN_TYPE_NAME_INT16: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int32
  static let BUILTIN_TYPE_NAME_INT32: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int64
  static let BUILTIN_TYPE_NAME_INT64: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int128
  static let BUILTIN_TYPE_NAME_INT128: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int256
  static let BUILTIN_TYPE_NAME_INT256: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Int512
  static let BUILTIN_TYPE_NAME_INT512: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for IntLiteral
  static let BUILTIN_TYPE_NAME_INTLITERAL: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for IEEE Floating point types.
  static let BUILTIN_TYPE_NAME_FLOAT: swift.BuiltinNameStringLiteral
  static let BUILTIN_TYPE_NAME_FLOAT_PPC: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for NativeObject
  static let BUILTIN_TYPE_NAME_NATIVEOBJECT: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for BridgeObject
  static let BUILTIN_TYPE_NAME_BRIDGEOBJECT: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for RawPointer
  static let BUILTIN_TYPE_NAME_RAWPOINTER: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for RawUnsafeContinuation
  static let BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for UnsafeValueBuffer
  static let BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Job
  static let BUILTIN_TYPE_NAME_JOB: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for DefaultActorStorage
  static let BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for UnknownObject
  ///
  /// This no longer exists as an AST-accessible type, but it's still used for
  /// fields shaped like AnyObject when ObjC interop is enabled.
  static let BUILTIN_TYPE_NAME_UNKNOWNOBJECT: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Vector
  static let BUILTIN_TYPE_NAME_VEC: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for SILToken
  static let BUILTIN_TYPE_NAME_SILTOKEN: swift.BuiltinNameStringLiteral

  /// The name of the Builtin type for Word
  static let BUILTIN_TYPE_NAME_WORD: swift.BuiltinNameStringLiteral

  /// Attempt to merge the ValueOwnershipKind of the passed in range's
  /// SILValues. Returns Optional<None> if we found an incompatibility.
  ///
  /// NOTE: This assumes that the passed in SILValues are not values used as type
  /// dependent operands.
  static func mergeSILValueOwnership(_ values: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE) -> swift.ValueOwnershipKind

  /// SILValue - A SILValue is a wrapper around a ValueBase pointer.
  struct SILValue {
    init(_ V: UnsafePointer<swift.ValueBase>!)
    static func * (lhs: inout swift.SILValue) -> UnsafeMutablePointer<swift.ValueBase>
    static func == (lhs: inout swift.SILValue, RHS: swift.SILValue) -> Bool
    static func == (lhs: inout swift.SILValue, RHS: UnsafeMutablePointer<swift.ValueBase>!) -> Bool
    static func != (lhs: inout swift.SILValue, RHS: swift.SILValue) -> Bool
    static func != (lhs: inout swift.SILValue, RHS: UnsafeMutablePointer<swift.ValueBase>!) -> Bool

    /// Get a location for this value.
    mutating func getLoc() -> swift.SILLocation

    /// Convert this SILValue into an opaque pointer like type. For use with
    /// PointerLikeTypeTraits.
    mutating func getOpaqueValue() -> UnsafeMutableRawPointer!

    /// Convert the given opaque pointer into a SILValue. For use with
    /// PointerLikeTypeTraits.
    static func getFromOpaqueValue(_ p: UnsafeMutableRawPointer!) -> swift.SILValue

    /// If this SILValue is a result of an instruction, return its
    /// defining instruction. Returns nullptr otherwise.
    mutating func getDefiningInstruction() -> UnsafeMutablePointer<swift.SILInstruction>!

    /// If this SILValue is a result of an instruction, return its
    /// defining instruction. Returns nullptr otherwise.
    mutating func getDefiningInstruction() -> UnsafePointer<swift.SILInstruction>!

    /// Returns the ValueOwnershipKind that describes this SILValue's ownership
    /// semantics if the SILValue has ownership semantics. Returns is a value
    /// without any Ownership Semantics.
    ///
    /// An example of a SILValue without ownership semantics is a
    /// struct_element_addr.
    ///
    /// NOTE: This is implemented in ValueOwnership.cpp not SILValue.cpp.
    mutating func getOwnershipKind() -> swift.ValueOwnershipKind

    /// Verify that this SILValue and its uses respects ownership invariants.
    mutating func verifyOwnership(_ DEBlocks: OpaquePointer!)
  }
  struct OwnershipConstraint {
    init(_ inputOwnershipKind: swift.OwnershipKind, _ inputLifetimeConstraint: swift.UseLifetimeConstraint)
    mutating func getPreferredKind() -> swift.OwnershipKind
    mutating func isLifetimeEnding() -> Bool
    mutating func getLifetimeConstraint() -> swift.UseLifetimeConstraint
    mutating func satisfiedBy(_ use: UnsafePointer<swift.Operand>!) -> Bool
    mutating func satisfiesConstraint(_ testKind: swift.ValueOwnershipKind) -> Bool
    static func == (lhs: inout swift.OwnershipConstraint, other: UnsafePointer<swift.OwnershipConstraint>) -> Bool
  }
  static func << (os: UnsafeMutablePointer<llvm.raw_ostream>, constraint: swift.OwnershipConstraint) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// Categorize all uses in terms of their ownership effect.
  ///
  /// Used to verify completeness of the ownership use model and exhaustively
  /// switch over any category of ownership use. Implies ownership constraints and
  /// lifetime constraints.
  struct OperandOwnership {
    struct innerty : Equatable, RawRepresentable {
      init(_ rawValue: UInt8)
      init(rawValue: UInt8)
      var rawValue: UInt8
      typealias RawValue = UInt8
    }
    var value: swift.OperandOwnership.innerty
    init(_ newValue: swift.OperandOwnership.innerty)
    mutating func asString() -> llvm.StringRef

    /// Return the OwnershipConstraint corresponding to this OperandOwnership.
    mutating func getOwnershipConstraint() -> swift.OwnershipConstraint
  }
  static func << (os: UnsafeMutablePointer<llvm.raw_ostream>, operandOwnership: UnsafePointer<swift.OperandOwnership>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// A formal SIL reference to a value, suitable for use as a stored
  /// operand.
  struct Operand {
    init(_ owner: UnsafeMutablePointer<swift.SILInstruction>!)
    init(_ owner: UnsafeMutablePointer<swift.SILInstruction>!, _ theValue: swift.SILValue)

    /// Return the current value being used by this operand.
    mutating func get() -> swift.SILValue

    /// Set the current value being used by this operand.
    mutating func set(_ newValue: swift.SILValue)

    /// Swap the given operand with the current one.
    mutating func swap(_ Op: UnsafeMutablePointer<swift.Operand>)

    /// Remove this use of the operand.
    mutating func drop()

    /// Return the user that owns this use.
    mutating func getUser() -> UnsafeMutablePointer<swift.SILInstruction>!
    mutating func getUser() -> UnsafePointer<swift.SILInstruction>!

    /// Return true if this operand is a type dependent operand.
    ///
    /// Implemented in SILInstruction.h
    mutating func isTypeDependent() -> Bool

    /// Return which operand this is in the operand list of the using instruction.
    mutating func getOperandNumber() -> UInt32

    /// Return the use ownership of this operand.
    ///
    /// NOTE: This is implemented in OperandOwnership.cpp.
    mutating func getOperandOwnership() -> swift.OperandOwnership

    /// Return the ownership constraint that restricts what types of values this
    /// Operand can contain.
    mutating func getOwnershipConstraint() -> swift.OwnershipConstraint

    /// Returns true if changing the operand to use a value with the given
    /// ownership kind, without rewriting the instruction, would not cause the
    /// operand to violate the operand's ownership constraints.
    mutating func canAcceptKind(_ kind: swift.ValueOwnershipKind) -> Bool

    /// Returns true if this operand and its value satisfy the operand's
    /// operand constraint.
    mutating func satisfiesConstraints() -> Bool

    /// Returns true if this operand acts as a use that ends the lifetime its
    /// associated value, either by consuming the owned value or ending the
    /// guaranteed scope.
    mutating func isLifetimeEnding() -> Bool
    mutating func getParentBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getParentFunction() -> UnsafeMutablePointer<swift.SILFunction>!
  }

  /// A class which adapts an array of Operands into an array of Values.
  ///
  /// The intent is that this should basically act exactly like
  /// ArrayRef except projecting away the Operand-ness.
  static func getSILValueType(_ op: UnsafePointer<swift.Operand>) -> swift.SILValue
  typealias OperandValueArrayRef = swift.__CxxTemplateInstN5swift12ArrayRefViewINS_7OperandENS_8SILValueEL_ZNS_15getSILValueTypeERKS1_ELb0EEE

  /// An iterator over all uses of a ValueBase.
  struct ValueBaseUseIterator {
    init()
    init(_ cur: UnsafeMutablePointer<swift.Operand>!)
    static func * (lhs: inout swift.ValueBaseUseIterator) -> UnsafeMutablePointer<swift.Operand>!
    mutating func getUser() -> UnsafeMutablePointer<swift.SILInstruction>!
  }
  struct ConsumingUseIterator {
    init(_ cur: UnsafeMutablePointer<swift.Operand>!)
  }
  struct NonConsumingUseIterator {
    init(_ cur: UnsafeMutablePointer<swift.Operand>!)
  }

  /// A constant-size list of the operands of an instruction.
  struct __CxxTemplateInstN5swift16FixedOperandListILj1EEE {

    /// Returns the full list of operands.
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Returns the full list of operand values.
    mutating func asValueArray() -> swift.OperandValueArrayRef
  }

  /// A constant-size list of the operands of an instruction.
  struct __CxxTemplateInstN5swift16FixedOperandListILj2EEE {

    /// Returns the full list of operands.
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Returns the full list of operand values.
    mutating func asValueArray() -> swift.OperandValueArrayRef
  }

  /// A constant-size list of the operands of an instruction.
  struct __CxxTemplateInstN5swift16FixedOperandListILj4EEE {

    /// Returns the full list of operands.
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm15MutableArrayRefIN5swift7OperandEEE
    mutating func asArray() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift7OperandEEE

    /// Returns the full list of operand values.
    mutating func asValueArray() -> swift.OperandValueArrayRef
  }

  /// A helper class for initializing the list of trailing operands.
  struct TrailingOperandsList {
    init()
    static func InitOperandsList(_ p: UnsafeMutablePointer<swift.Operand>!, _ user: UnsafeMutablePointer<swift.SILInstruction>!, _ operand: swift.SILValue, _ operands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE)
    static func InitOperandsList(_ p: UnsafeMutablePointer<swift.Operand>!, _ user: UnsafeMutablePointer<swift.SILInstruction>!, _ operand0: swift.SILValue, _ operand1: swift.SILValue, _ operands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE)
    static func InitOperandsList(_ p: UnsafeMutablePointer<swift.Operand>!, _ user: UnsafeMutablePointer<swift.SILInstruction>!, _ operands: llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift8SILValueEEE)
  }

  /// SILValue hashes just like a pointer.
  static func hash_value(_ V: swift.SILValue) -> llvm.hash_code
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, V: swift.SILValue) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// An enumeration which contains values for all the concrete ValueBase
  /// subclasses.
  enum ValueKind : std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type {
    init?(rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type)
    var rawValue: std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type { get }
    typealias RawValue = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift11SILNodeKindELb1EEE.type
    case SILPhiArgument
    case SILFunctionArgument
    static var First_SILArgument: swift.ValueKind { get }
    static var Last_SILArgument: swift.ValueKind { get }
    case BeginApplyResult
    case BeginCOWMutationResult
    case DestructureStructResult
    case DestructureTupleResult
    static var First_MultipleValueInstructionResult: swift.ValueKind { get }
    static var Last_MultipleValueInstructionResult: swift.ValueKind { get }
    case SILUndef
    case AllocStackInst
    case AllocRefInst
    case AllocRefDynamicInst
    case AllocValueBufferInst
    case AllocBoxInst
    case AllocExistentialBoxInst
    static var First_AllocationInst: swift.ValueKind { get }
    static var Last_AllocationInst: swift.ValueKind { get }
    case IndexAddrInst
    case TailAddrInst
    case IndexRawPointerInst
    static var First_IndexingInst: swift.ValueKind { get }
    static var Last_IndexingInst: swift.ValueKind { get }
    case FunctionRefInst
    case DynamicFunctionRefInst
    case PreviousDynamicFunctionRefInst
    case GlobalAddrInst
    case BaseAddrForOffsetInst
    case GlobalValueInst
    case IntegerLiteralInst
    case FloatLiteralInst
    case StringLiteralInst
    static var First_LiteralInst: swift.ValueKind { get }
    static var Last_LiteralInst: swift.ValueKind { get }
    case ClassMethodInst
    case SuperMethodInst
    case ObjCMethodInst
    case ObjCSuperMethodInst
    case WitnessMethodInst
    static var First_MethodInst: swift.ValueKind { get }
    static var Last_MethodInst: swift.ValueKind { get }
    case UpcastInst
    case AddressToPointerInst
    case PointerToAddressInst
    case UncheckedRefCastInst
    case UncheckedAddrCastInst
    case UncheckedTrivialBitCastInst
    case UncheckedBitwiseCastInst
    case UncheckedValueCastInst
    case RefToRawPointerInst
    case RawPointerToRefInst
    case RefToUnownedInst
    case UnownedToRefInst
    case RefToUnmanagedInst
    case UnmanagedToRefInst
    case ConvertFunctionInst
    case ConvertEscapeToNoEscapeInst
    case ThinFunctionToPointerInst
    case PointerToThinFunctionInst
    case RefToBridgeObjectInst
    case BridgeObjectToRefInst
    case BridgeObjectToWordInst
    case ThinToThickFunctionInst
    case ThickToObjCMetatypeInst
    case ObjCToThickMetatypeInst
    case ObjCMetatypeToObjectInst
    case ObjCExistentialMetatypeToObjectInst
    case UnconditionalCheckedCastValueInst
    case UnconditionalCheckedCastInst
    static var First_ConversionInst: swift.ValueKind { get }
    static var Last_ConversionInst: swift.ValueKind { get }
    case ClassifyBridgeObjectInst
    case ValueToBridgeObjectInst
    case MarkDependenceInst
    case CopyBlockInst
    case CopyBlockWithoutEscapingInst
    case CopyValueInst
    case StrongCopyUnownedValueInst
    case StrongCopyUnmanagedValueInst
    case UncheckedOwnershipConversionInst
    case IsUniqueInst
    case EndCOWMutationInst
    case IsEscapingClosureInst
    case LoadInst
    case LoadBorrowInst
    case BeginBorrowInst
    case StoreBorrowInst
    case BeginAccessInst
    case LoadWeakInst
    case LoadUnownedInst
    case MarkUninitializedInst
    case ProjectValueBufferInst
    case ProjectBoxInst
    case ProjectExistentialBoxInst
    case ApplyInst
    case BuiltinInst
    case PartialApplyInst
    case MetatypeInst
    case ValueMetatypeInst
    case ExistentialMetatypeInst
    case ObjCProtocolInst
    case ObjectInst
    case TupleInst
    case TupleExtractInst
    case TupleElementAddrInst
    case StructInst
    case StructExtractInst
    case StructElementAddrInst
    case RefElementAddrInst
    case RefTailAddrInst
    case EnumInst
    case UncheckedEnumDataInst
    case InitEnumDataAddrInst
    case UncheckedTakeEnumDataAddrInst
    case SelectEnumInst
    case SelectEnumAddrInst
    case SelectValueInst
    case InitExistentialAddrInst
    case InitExistentialValueInst
    case OpenExistentialAddrInst
    case InitExistentialRefInst
    case OpenExistentialRefInst
    case InitExistentialMetatypeInst
    case OpenExistentialMetatypeInst
    case OpenExistentialBoxInst
    case OpenExistentialValueInst
    case OpenExistentialBoxValueInst
    case ProjectBlockStorageInst
    case InitBlockStorageHeaderInst
    case DifferentiableFunctionInst
    case LinearFunctionInst
    case DifferentiableFunctionExtractInst
    case LinearFunctionExtractInst
    case DifferentiabilityWitnessFunctionInst
    case GetAsyncContinuationInst
    case GetAsyncContinuationAddrInst
    static var First_GetAsyncContinuationInstBase: swift.ValueKind { get }
    static var Last_GetAsyncContinuationInstBase: swift.ValueKind { get }
    case KeyPathInst
    static var First_SingleValueInstruction: swift.ValueKind { get }
    static var Last_SingleValueInstruction: swift.ValueKind { get }
  }

  /// ValueKind hashes to its underlying integer representation.
  static func hash_value(_ K: swift.ValueKind) -> llvm.hash_code

  /// What constraint does the given use of an SSA value put on the lifetime of
  /// the given SSA value.
  ///
  /// There are two possible constraints: NonLifetimeEnding and
  /// LifetimeEnding. NonLifetimeEnding means that the SSA value must be
  /// able to be used in a valid way at the given use
  /// point. LifetimeEnding means that the value has been invalidated at
  /// the given use point and any uses reachable from that point are
  /// invalid in SIL causing a SIL verifier error.
  enum UseLifetimeConstraint : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32

    /// This use requires the SSA value to be live after the given instruction's
    /// execution.
    case NonLifetimeEnding

    /// This use invalidates the given SSA value.
    ///
    /// This means that the given SSA value can not have any uses that are
    /// reachable from this instruction. When a value has owned semantics this
    /// means the SSA value is destroyed at this point. When a value has
    /// guaranteed (i.e. shared borrow) semantics this means that the program
    /// has left the scope of the borrowed SSA value and said value can not be
    /// used.
    case LifetimeEnding
  }
  static func << (os: UnsafeMutablePointer<llvm.raw_ostream>, constraint: swift.UseLifetimeConstraint) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// A lattice that we use to classify ownership at the SIL level. None is top
  /// and Any is bottom and all of the other ownership kinds are mid level nodes
  /// in the lattice. Graphically the lattice looks as follows:
  ///             +----+
  ///     +-------|None|---------+
  ///     |       +----+         |
  ///     |          |           |
  ///     v          v           v
  /// +-------+   +-----+   +----------+
  /// |Unowned|   |Owned|   |Guaranteed|
  /// +-------+   +-----+   +----------+
  ///     |          |           |
  ///     |          v           |
  ///     |        +---+         |
  ///     +------->|Any|<--------+
  ///              +---+
  ///
  /// One moves up the lattice by performing a join operation and one moves down
  /// the lattice by performing a meet operation.
  ///
  /// This type is used in two different composition types:
  ///
  /// * ValueOwnershipKind: This represents the ownership kind that a value can
  ///   take. Since our ownership system is strict, we require that all values
  ///   have a non-Any ownership since Any represents a type of ownership unknown
  ///   statically. Thus we treat Any as representing an invalid
  ///   value. ValueOwnershipKinds can only perform a meet operation to determine
  ///   if two ownership kinds are compatible with a merge of Any showing the
  ///   merge is impossible since values can not have any ownership.
  ///
  /// * OperandConstraint: This represents a constraint on the values that can be
  ///   used by a specific operand. Here Any is valid.
  struct OwnershipKind {
    struct innerty : Equatable, RawRepresentable {
      init(_ rawValue: UInt8)
      init(rawValue: UInt8)
      var rawValue: UInt8
      typealias RawValue = UInt8
    }
    typealias UnderlyingType = std.__1.__CxxTemplateInstNSt3__122__underlying_type_implIN5swift13OwnershipKind7innertyELb1EEE.type
    static let NumBits: UInt32
    static let MaxValue: swift.OwnershipKind.UnderlyingType
    static let Mask: UInt64
    var value: swift.OwnershipKind.innerty
    init(_ other: swift.OwnershipKind.innerty)

    /// Move down the lattice.
    mutating func meet(_ other: swift.OwnershipKind) -> swift.OwnershipKind

    /// Move up the lattice.
    mutating func join(_ other: swift.OwnershipKind) -> swift.OwnershipKind

    /// Convert this ownership kind to a StringRef.
    mutating func asString() -> llvm.StringRef
  }
  static func << (os: UnsafeMutablePointer<llvm.raw_ostream>, kind: UnsafePointer<swift.OwnershipKind>) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// A value representing the specific ownership semantics that a SILValue may
  /// have.
  struct ValueOwnershipKind {
    typealias innerty = swift.OwnershipKind.innerty
    var value: swift.OwnershipKind
    init(_ newValue: swift.ValueOwnershipKind.innerty)
    init(_ newValue: swift.OwnershipKind)
    init(_ newValue: UInt32)
    init(_ f: UnsafePointer<swift.SILFunction>, _ type: swift.SILType, _ convention: swift.SILArgumentConvention)

    /// Parse Value into a ValueOwnershipKind.
    ///
    /// *NOTE* Emits an unreachable if an invalid value is passed in.
    init(_ value: llvm.StringRef)
    static func == (lhs: inout swift.ValueOwnershipKind, other: swift.ValueOwnershipKind) -> Bool
    static func == (lhs: inout swift.ValueOwnershipKind, other: swift.ValueOwnershipKind.innerty) -> Bool

    /// We merge by moving down the lattice.
    mutating func merge(_ rhs: swift.ValueOwnershipKind) -> swift.ValueOwnershipKind

    /// Given that there is an aggregate value (like a struct or enum) with this
    /// ownership kind, and a subobject of type Proj is being projected from the
    /// aggregate, return Trivial if Proj has trivial type and the aggregate's
    /// ownership kind otherwise.
    mutating func getProjectedOwnershipKind(_ func: UnsafePointer<swift.SILFunction>, _ projType: swift.SILType) -> swift.ValueOwnershipKind

    /// Return the lifetime constraint semantics for this
    /// ValueOwnershipKind when forwarding ownership.
    ///
    /// This is MustBeInvalidated for Owned and MustBeLive for all other ownership
    /// kinds.
    mutating func getForwardingLifetimeConstraint() -> swift.UseLifetimeConstraint

    /// Return the OperandOwnership for a forwarded operand when the forwarded
    /// result has this ValueOwnershipKind. \p allowUnowned is true for a subset
    /// of forwarding operations that are allowed to propagate Unowned values.
    mutating func getForwardingOperandOwnership(_ allowUnowned: Bool) -> swift.OperandOwnership

    /// Returns true if \p Other can be merged successfully with this, implying
    /// that the two ownership kinds are "compatibile".
    ///
    /// The reason why we do not compare directy is to allow for
    /// OwnershipKind::None to merge into other forms of ValueOwnershipKind.
    mutating func isCompatibleWith(_ other: swift.ValueOwnershipKind) -> Bool

    /// Returns isCompatibleWith(other.getOwnershipKind()).
    ///
    /// Definition is inline after SILValue is defined to work around circular
    /// dependencies.
    mutating func isCompatibleWith(_ other: swift.SILValue) -> Bool
    static func merge<RangeTy>(_ r: UnsafeMutablePointer<RangeTy>) -> swift.ValueOwnershipKind
    mutating func asString() -> llvm.StringRef
  }
  static func << (os: UnsafeMutablePointer<llvm.raw_ostream>, Kind: swift.ValueOwnershipKind) -> UnsafeMutablePointer<llvm.raw_ostream>

  /// An enumeration which contains values for all the nodes in SILNodes.def.
  /// Other enumerators, like ValueKind and SILInstructionKind, ultimately
  /// take their values from this enumerator.
  enum SILNodeKind : Int32 {
    init?(rawValue: Int32)
    var rawValue: Int32 { get }
    typealias RawValue = Int32
    case SILPhiArgument
    case SILFunctionArgument
    static var First_SILArgument: swift.SILNodeKind { get }
    static var Last_SILArgument: swift.SILNodeKind { get }
    case BeginApplyResult
    case BeginCOWMutationResult
    case DestructureStructResult
    case DestructureTupleResult
    static var First_MultipleValueInstructionResult: swift.SILNodeKind { get }
    static var Last_MultipleValueInstructionResult: swift.SILNodeKind { get }
    case SILUndef
    case AllocStackInst
    case AllocRefInst
    case AllocRefDynamicInst
    case AllocValueBufferInst
    case AllocBoxInst
    case AllocExistentialBoxInst
    static var First_AllocationInst: swift.SILNodeKind { get }
    static var Last_AllocationInst: swift.SILNodeKind { get }
    case IndexAddrInst
    case TailAddrInst
    case IndexRawPointerInst
    static var First_IndexingInst: swift.SILNodeKind { get }
    static var Last_IndexingInst: swift.SILNodeKind { get }
    case FunctionRefInst
    case DynamicFunctionRefInst
    case PreviousDynamicFunctionRefInst
    case GlobalAddrInst
    case BaseAddrForOffsetInst
    case GlobalValueInst
    case IntegerLiteralInst
    case FloatLiteralInst
    case StringLiteralInst
    static var First_LiteralInst: swift.SILNodeKind { get }
    static var Last_LiteralInst: swift.SILNodeKind { get }
    case ClassMethodInst
    case SuperMethodInst
    case ObjCMethodInst
    case ObjCSuperMethodInst
    case WitnessMethodInst
    static var First_MethodInst: swift.SILNodeKind { get }
    static var Last_MethodInst: swift.SILNodeKind { get }
    case UpcastInst
    case AddressToPointerInst
    case PointerToAddressInst
    case UncheckedRefCastInst
    case UncheckedAddrCastInst
    case UncheckedTrivialBitCastInst
    case UncheckedBitwiseCastInst
    case UncheckedValueCastInst
    case RefToRawPointerInst
    case RawPointerToRefInst
    case RefToUnownedInst
    case UnownedToRefInst
    case RefToUnmanagedInst
    case UnmanagedToRefInst
    case ConvertFunctionInst
    case ConvertEscapeToNoEscapeInst
    case ThinFunctionToPointerInst
    case PointerToThinFunctionInst
    case RefToBridgeObjectInst
    case BridgeObjectToRefInst
    case BridgeObjectToWordInst
    case ThinToThickFunctionInst
    case ThickToObjCMetatypeInst
    case ObjCToThickMetatypeInst
    case ObjCMetatypeToObjectInst
    case ObjCExistentialMetatypeToObjectInst
    case UnconditionalCheckedCastValueInst
    case UnconditionalCheckedCastInst
    static var First_ConversionInst: swift.SILNodeKind { get }
    static var Last_ConversionInst: swift.SILNodeKind { get }
    case ClassifyBridgeObjectInst
    case ValueToBridgeObjectInst
    case MarkDependenceInst
    case CopyBlockInst
    case CopyBlockWithoutEscapingInst
    case CopyValueInst
    case StrongCopyUnownedValueInst
    case StrongCopyUnmanagedValueInst
    case UncheckedOwnershipConversionInst
    case IsUniqueInst
    case EndCOWMutationInst
    case IsEscapingClosureInst
    case LoadInst
    case LoadBorrowInst
    case BeginBorrowInst
    case StoreBorrowInst
    case BeginAccessInst
    case LoadWeakInst
    case LoadUnownedInst
    case MarkUninitializedInst
    case ProjectValueBufferInst
    case ProjectBoxInst
    case ProjectExistentialBoxInst
    case ApplyInst
    case BuiltinInst
    case PartialApplyInst
    case MetatypeInst
    case ValueMetatypeInst
    case ExistentialMetatypeInst
    case ObjCProtocolInst
    case ObjectInst
    case TupleInst
    case TupleExtractInst
    case TupleElementAddrInst
    case StructInst
    case StructExtractInst
    case StructElementAddrInst
    case RefElementAddrInst
    case RefTailAddrInst
    case EnumInst
    case UncheckedEnumDataInst
    case InitEnumDataAddrInst
    case UncheckedTakeEnumDataAddrInst
    case SelectEnumInst
    case SelectEnumAddrInst
    case SelectValueInst
    case InitExistentialAddrInst
    case InitExistentialValueInst
    case OpenExistentialAddrInst
    case InitExistentialRefInst
    case OpenExistentialRefInst
    case InitExistentialMetatypeInst
    case OpenExistentialMetatypeInst
    case OpenExistentialBoxInst
    case OpenExistentialValueInst
    case OpenExistentialBoxValueInst
    case ProjectBlockStorageInst
    case InitBlockStorageHeaderInst
    case DifferentiableFunctionInst
    case LinearFunctionInst
    case DifferentiableFunctionExtractInst
    case LinearFunctionExtractInst
    case DifferentiabilityWitnessFunctionInst
    case GetAsyncContinuationInst
    case GetAsyncContinuationAddrInst
    static var First_GetAsyncContinuationInstBase: swift.SILNodeKind { get }
    static var Last_GetAsyncContinuationInstBase: swift.SILNodeKind { get }
    case KeyPathInst
    static var First_SingleValueInstruction: swift.SILNodeKind { get }
    static var Last_SingleValueInstruction: swift.SILNodeKind { get }
    static var First_ValueBase: swift.SILNodeKind { get }
    static var Last_ValueBase: swift.SILNodeKind { get }
    case UnreachableInst
    case ReturnInst
    case ThrowInst
    case YieldInst
    case UnwindInst
    case TryApplyInst
    case BranchInst
    case CondBranchInst
    case SwitchValueInst
    case SwitchEnumInst
    case SwitchEnumAddrInst
    case DynamicMethodBranchInst
    case AwaitAsyncContinuationInst
    case CheckedCastBranchInst
    case CheckedCastAddrBranchInst
    case CheckedCastValueBranchInst
    static var First_TermInst: swift.SILNodeKind { get }
    static var Last_TermInst: swift.SILNodeKind { get }
    case DeallocStackInst
    case DeallocRefInst
    case DeallocPartialRefInst
    case DeallocValueBufferInst
    case DeallocBoxInst
    case DeallocExistentialBoxInst
    static var First_DeallocationInst: swift.SILNodeKind { get }
    static var Last_DeallocationInst: swift.SILNodeKind { get }
    case StrongRetainInst
    case StrongReleaseInst
    case UnmanagedRetainValueInst
    case UnmanagedReleaseValueInst
    case UnmanagedAutoreleaseValueInst
    case StrongRetainUnownedInst
    case UnownedRetainInst
    case UnownedReleaseInst
    case RetainValueInst
    case RetainValueAddrInst
    case ReleaseValueInst
    case ReleaseValueAddrInst
    case SetDeallocatingInst
    case AutoreleaseValueInst
    static var First_RefCountingInst: swift.SILNodeKind { get }
    static var Last_RefCountingInst: swift.SILNodeKind { get }
    case BindMemoryInst
    case FixLifetimeInst
    case HopToExecutorInst
    case DestroyValueInst
    case EndBorrowInst
    case EndAccessInst
    case BeginUnpairedAccessInst
    case EndUnpairedAccessInst
    case StoreInst
    case AssignInst
    case AssignByWrapperInst
    case MarkFunctionEscapeInst
    case DebugValueInst
    case DebugValueAddrInst
    case StoreWeakInst
    case StoreUnownedInst
    case CopyAddrInst
    case DestroyAddrInst
    case EndLifetimeInst
    case InjectEnumAddrInst
    case DeinitExistentialAddrInst
    case DeinitExistentialValueInst
    case UnconditionalCheckedCastAddrInst
    case UncheckedRefCastAddrInst
    case AllocGlobalInst
    case EndApplyInst
    case AbortApplyInst
    case CondFailInst
    static var First_NonValueInstruction: swift.SILNodeKind { get }
    static var Last_NonValueInstruction: swift.SILNodeKind { get }
    case BeginApplyInst
    case BeginCOWMutationInst
    case DestructureStructInst
    case DestructureTupleInst
    static var First_MultipleValueInstruction: swift.SILNodeKind { get }
    static var Last_MultipleValueInstruction: swift.SILNodeKind { get }
    static var First_SILInstruction: swift.SILNodeKind { get }
    static var Last_SILInstruction: swift.SILNodeKind { get }
    static var First_SILNode: swift.SILNodeKind { get }
    static var Last_SILNode: swift.SILNodeKind { get }
  }

  /// A SILNode is a node in the use-def graph of a SILFunction.  It is
  /// either an instruction or a defined value which can be used by an
  /// instruction.  A defined value may be an instruction result, a basic
  /// block argument, or the special 'undef' value.
  ///
  /// The 'node' intuition is slightly imprecise because a single instruction
  /// may be composed of multiple SILNodes: one for the instruction itself
  /// and one for each value it produces.  When an instruction kind always
  /// produces exactly one value, the cast machinery (isa, cast, and dyn_cast)
  /// works to make both nodes appear to be the same object: there is a value
  /// kind exactly equal to the instruction kind and the value node can be
  /// directly cast to the instruction's class.  When an instruction kind
  /// never produces values, it has no corresponding value kind, and it is
  /// a compile-time error to attempt to cast a value node to the instruction
  /// class.  When an instruction kind can have multiple values (not yet
  /// implemented), its value nodes have a different kind from the
  /// instruction kind and it is a static error to attempt to cast a value
  /// node to the instruction kind.
  ///
  /// Another way of interpreting SILNode is that there is a SILNode for
  /// everything that can be numbered in SIL assembly (plus 'undef', which
  /// is not conventionally numbered).  Instructions without results are
  /// still numbered in SIL in order to describe the users lists of an
  /// instruction or argument.  Instructions with multiple results are
  /// numbered using their first result.
  ///
  /// SILNode is a base class of both SILInstruction and ValueBase.
  /// Because there can be multiple SILNodes within a single instruction
  /// object, some care must be taken when working with SILNode pointers.
  /// These precautions only apply to SILNode* and not its subclasses.
  ///
  /// - There may have multiple SILNode* values that refer to the same
  ///   instruction.  Data structures and algorithms that rely on uniqueness of a
  ///   SILNode* should generally make sure that they're working with the
  ///   representative SILNode*; see getRepresentativeSILNodeInObject().
  ///
  /// - Do not use builtin C++ casts to downcast a SILNode*.  A static_cast
  ///   from SILNode* to SILInstruction* only works if the referenced
  ///   SILNode is the base subobject of the object's SILInstruction
  ///   subobject.  If the SILNode is actually the base subobject of a
  ///   ValueBase subobject, the cast will yield a corrupted value.
  ///   Always use the LLVM casts (cast<>, dyn_cast<>, etc.) instead.
  struct SILNode {

    /// Does the given kind of node inherit from multiple multiple SILNode base
    /// classes?
    ///
    /// This enables one to know if their is a diamond in the inheritence
    /// hierarchy for this SILNode.
    static func hasMultipleSILNodeBases(_ kind: swift.SILNodeKind) -> Bool

    /// Is this SILNode the representative SILNode subobject in this object?
    mutating func isRepresentativeSILNodeInObject() -> Bool

    /// Return a pointer to the representative SILNode subobject in this object.
    mutating func getRepresentativeSILNodeInObject() -> UnsafeMutablePointer<swift.SILNode>!
    mutating func getRepresentativeSILNodeInObject() -> UnsafePointer<swift.SILNode>!
    mutating func getKind() -> swift.SILNodeKind

    /// Return the SILNodeKind of this node's representative SILNode.
    mutating func getKindOfRepresentativeSILNodeInObject() -> swift.SILNodeKind

    /// If this is a SILArgument or a SILInstruction get its parent basic block,
    /// otherwise return null.
    mutating func getParentBlock() -> UnsafeMutablePointer<swift.SILBasicBlock>!

    /// If this is a SILArgument or a SILInstruction get its parent function,
    /// otherwise return null.
    mutating func getFunction() -> UnsafeMutablePointer<swift.SILFunction>!

    /// If this is a SILArgument or a SILInstruction get its parent module,
    /// otherwise return null.
    mutating func getModule() -> UnsafeMutablePointer<swift.SILModule>!

    /// Pretty-print the node.  If the node is an instruction, the output
    /// will be valid SIL assembly; otherwise, it will be an arbitrary
    /// format suitable for debugging.
    @warn_unqualified_access
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
    mutating func dump()

    /// Pretty-print the node in context, preceded by its operands (if the
    /// value represents the result of an instruction) and followed by its
    /// users.
    mutating func printInContext(_ OS: UnsafeMutablePointer<llvm.raw_ostream>)
    mutating func dumpInContext()
    mutating func castToSingleValueInstruction() -> UnsafeMutablePointer<swift.SingleValueInstruction>!
    mutating func castToSingleValueInstruction() -> UnsafePointer<swift.SingleValueInstruction>!
    static func classof(_ node: UnsafePointer<swift.SILNode>!) -> Bool
  }
  static func << (OS: UnsafeMutablePointer<llvm.raw_ostream>, node: UnsafePointer<swift.SILNode>) -> UnsafeMutablePointer<llvm.raw_ostream>
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_14SILInstructionEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_9ApplyInstEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_14BeginApplyInstEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_12TryApplyInstEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_16PartialApplyInstEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift28cast_sil_node_is_unambiguousINS_9ValueBaseEEE {
    static let value: Bool
    init()
    init(value: Bool)
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_14SILInstructionELb0ELb0EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.SILInstruction>!
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_9ApplyInstELb1ELb0EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.ApplyInst>!
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_14BeginApplyInstELb0ELb1EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.BeginApplyInst>!
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_12TryApplyInstELb0ELb1EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.TryApplyInst>!
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_16PartialApplyInstELb1ELb0EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.PartialApplyInst>!
  }
  struct __CxxTemplateInstN5swift13cast_sil_nodeINS_9ValueBaseELb0ELb0EEE {
    init()
    static func doit(_ node: UnsafeMutablePointer<swift.SILNode>!) -> UnsafeMutablePointer<swift.ValueBase>!
  }

  /// An edge in the control flow graph.
  ///
  /// A SILSuccessor is stored in the terminator instruction of the tail block of
  /// the CFG edge. Internally it has a back reference to the terminator that
  /// contains it (ContainingInst). It also contains the SuccessorBlock that is
  /// the "head" of the CFG edge. This makes it very simple to iterate over the
  /// successors of a specific block.
  ///
  /// SILSuccessor also enables given a "head" edge the ability to iterate over
  /// predecessors. This is done by using an ilist that is embedded into
  /// SILSuccessors.
  struct SILSuccessor {

    /// This is an iterator for walking the predecessor list of a SILBasicBlock.
    struct pred_iterator {
      typealias difference_type = Int
      typealias value_type = UnsafeMutablePointer<swift.SILBasicBlock>
      typealias pointer = UnsafeMutablePointer<UnsafeMutablePointer<swift.SILBasicBlock>?>
      typealias reference = UnsafeMutablePointer<UnsafeMutablePointer<swift.SILBasicBlock>?>
      typealias iterator_category = std.__1.forward_iterator_tag
      init(_ Cur: UnsafeMutablePointer<swift.SILSuccessor>!)
      static func == (lhs: inout swift.SILSuccessor.pred_iterator, I2: swift.SILSuccessor.pred_iterator) -> Bool
      static func != (lhs: inout swift.SILSuccessor.pred_iterator, I2: swift.SILSuccessor.pred_iterator) -> Bool
      static func + (lhs: inout swift.SILSuccessor.pred_iterator, distance: UInt32) -> swift.SILSuccessor.pred_iterator
      mutating func getSuccessorRef() -> UnsafeMutablePointer<swift.SILSuccessor>!
      static func * (lhs: inout swift.SILSuccessor.pred_iterator) -> UnsafeMutablePointer<swift.SILBasicBlock>!
    }
    init(_ Count: swift.ProfileCounter)
    init(_ CI: UnsafeMutablePointer<swift.TermInst>!, _ Count: swift.ProfileCounter)
    init(_ CI: UnsafeMutablePointer<swift.TermInst>!, _ Succ: UnsafeMutablePointer<swift.SILBasicBlock>!, _ Count: swift.ProfileCounter)
    mutating func getBB() -> UnsafeMutablePointer<swift.SILBasicBlock>!
    mutating func getCount() -> swift.ProfileCounter
  }

  /// SourceLoc in swift is just an SMLoc.  We define it as a different type
  /// (instead of as a typedef) just to remove the "getFromPointer" methods and
  /// enforce purity in the Swift codebase.
  struct SourceLoc {
    init()
    init(_ Value: llvm.SMLoc)
    mutating func isValid() -> Bool
    mutating func isInvalid() -> Bool
    static func == (lhs: inout swift.SourceLoc, RHS: UnsafePointer<swift.SourceLoc>) -> Bool
    static func != (lhs: inout swift.SourceLoc, RHS: UnsafePointer<swift.SourceLoc>) -> Bool

    /// Return a source location advanced a specified number of bytes.
    mutating func getAdvancedLoc(_ ByteOffset: Int32) -> swift.SourceLoc
    mutating func getAdvancedLocOrInvalid(_ ByteOffset: Int32) -> swift.SourceLoc
    mutating func getOpaquePointerValue() -> UnsafeRawPointer!

    /// Print out the SourceLoc.  If this location is in the same buffer
    /// as specified by \c LastBufferID, then we don't print the filename.  If
    /// not, we do print the filename, and then update \c LastBufferID with the
    /// BufferID printed.
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ SM: UnsafePointer<swift.SourceManager>, _ LastBufferID: UnsafeMutablePointer<UInt32>)
    mutating func printLineAndColumn(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ SM: UnsafePointer<swift.SourceManager>, _ BufferID: UInt32)
    mutating func print(_ OS: UnsafeMutablePointer<llvm.raw_ostream>, _ SM: UnsafePointer<swift.SourceManager>)
    @available(*, deprecated, message: "only for use in the debugger")
    mutating func dump(_ SM: UnsafePointer<swift.SourceManager>)
  }

  /// Base class for function-like declarations.
  struct AbstractFunctionDecl {
    enum BodyKind : Int32 {
      init?(rawValue: Int32)
      var rawValue: Int32 { get }
      typealias RawValue = Int32

      /// The function did not have a body in the source code file.
      case None

      /// Function body is delayed, to be parsed later.
      case Unparsed

      /// Function body is parsed and available as an AST subtree.
      case Parsed

      /// Function body is not available, although it was written in the source.
      case Skipped

      /// Function body will be synthesized on demand.
      case Synthesize

      /// Function body is present and type-checked.
      case TypeChecked

      /// This is a memberwise initializer that will be synthesized by SILGen.
      case MemberwiseInitializer

      /// Function body text was deserialized from a .swiftmodule.
      case Deserialized
    }
    struct BodySynthesizer {
      var Fn: (@convention(c) (UnsafeMutablePointer<swift.AbstractFunctionDecl>?, UnsafeMutableRawPointer?) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift9BraceStmtEbEE)!
      var Context: UnsafeMutableRawPointer!
      init()
      init(Fn: (@convention(c) (UnsafeMutablePointer<swift.AbstractFunctionDecl>?, UnsafeMutableRawPointer?) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift9BraceStmtEbEE)!, Context: UnsafeMutableRawPointer!)
    }
    mutating func getBodyKind() -> swift.AbstractFunctionDecl.BodyKind

    /// Get all derivative function configurations.
    mutating func getDerivativeFunctionConfigurations() -> llvm.__CxxTemplateInstN4llvm8ArrayRefIN5swift14AutoDiffConfigEEE

    /// Add the given derivative function configuration.
    mutating func addDerivativeFunctionConfiguration(_ config: swift.AutoDiffConfig)
    mutating func setHasSingleExpressionBody(_ Has: Bool)
    mutating func hasSingleExpressionBody() -> Bool
    mutating func getSingleExpressionBody() -> OpaquePointer!
    mutating func setSingleExpressionBody(_ NewBody: OpaquePointer!)

    /// Returns the string for the base name, or "_" if this is unnamed.
    mutating func getNameStr() -> llvm.StringRef

    /// Should this declaration be treated as if annotated with transparent
    /// attribute.
    mutating func isTransparent() -> Bool
    mutating func getImportAsMemberStatus() -> swift.ImportAsMemberStatus
    mutating func isImportAsMember() -> Bool
    mutating func isImportAsInstanceMember() -> Bool
    mutating func isImportAsStaticMember() -> Bool
    mutating func getSelfIndex() -> UInt8
    mutating func setImportAsStaticMember()
    mutating func setSelfIndex(_ idx: UInt8)

    /// Retrieve the location of the 'async' keyword, if present.
    mutating func getAsyncLoc() -> swift.SourceLoc

    /// Retrieve the location of the 'throws' keyword, if present.
    mutating func getThrowsLoc() -> swift.SourceLoc

    /// Returns true if the function is marked as `async`. The
    /// type of the function will be `async` as well.
    mutating func hasAsync() -> Bool

    /// Returns true if the function is a suitable 'async' context.
    ///
    /// Functions that are an 'async' context can make calls to 'async' functions.
    mutating func isAsyncContext() -> Bool

    /// Returns true if the function is an @asyncHandler.
    mutating func isAsyncHandler() -> Bool

    /// Returns true if the function signature matches the form of an
    /// @asyncHandler.
    mutating func canBeAsyncHandler() -> Bool

    /// Returns true if the function body throws.
    mutating func hasThrows() -> Bool
    mutating func getEffectiveFullName() -> swift.DeclName

    /// Returns true if the function has a body written in the source file.
    ///
    /// Note that a true return value does not imply that the body was actually
    /// parsed.
    mutating func hasBody() -> Bool

    /// Returns true if the text of this function's body can be retrieved either
    /// by extracting the text from the source buffer or reading the inlinable
    /// body from a deserialized swiftmodule.
    mutating func hasInlinableBodyText() -> Bool

    /// Returns the function body, if it was parsed, or nullptr otherwise.
    ///
    /// Note that a null return value does not imply that the source code did not
    /// have a body for this function.
    ///
    /// \sa hasBody()
    mutating func getBody(_ canSynthesize: Bool) -> OpaquePointer!

    /// Retrieve the type-checked body of the given function, or \c nullptr if
    /// there's no body available.
    mutating func getTypecheckedBody() -> OpaquePointer!

    /// Set a new body for the function.
    mutating func setBody(_ S: OpaquePointer!, _ NewBodyKind: swift.AbstractFunctionDecl.BodyKind)

    /// Note that the body was skipped for this function. Function body
    /// cannot be attached after this call.
    mutating func setBodySkipped(_ bodyRange: swift.SourceRange)

    /// Note that parsing for the body was delayed.
    mutating func setBodyDelayed(_ bodyRange: swift.SourceRange)
    mutating func setBodyToBeReparsed(_ bodyRange: swift.SourceRange)

    /// Provide the parsed body for the function.
    mutating func setBodyParsed(_ S: OpaquePointer!)

    /// Was there a nested type declaration detected when parsing this
    /// function was skipped?
    mutating func hasNestedTypeDeclarations() -> Bool
    mutating func setHasNestedTypeDeclarations(_ value: Bool)

    /// Note that parsing for the body was delayed.
    ///
    /// The function should return the body statement and a flag indicating
    /// whether that body is already type-checked.
    mutating func setBodySynthesizer(_ fn: (@convention(c) (UnsafeMutablePointer<swift.AbstractFunctionDecl>?, UnsafeMutableRawPointer?) -> std.__1.__CxxTemplateInstNSt3__14pairIPN5swift9BraceStmtEbEE)!, _ context: UnsafeMutableRawPointer!)

    /// Note that this is a memberwise initializer and thus the body will be
    /// generated by SILGen.
    mutating func setIsMemberwiseInitializer()

    /// Gets the body of this function, stripping the unused portions of #if
    /// configs inside the body. If this function was not deserialized from a
    /// .swiftmodule, this body is reconstructed from the original
    /// source buffer.
    mutating func getInlinableBodyText(_ scratch: UnsafeMutablePointer<llvm.__CxxTemplateInstN4llvm15SmallVectorImplIcEE>) -> llvm.StringRef
    mutating func setBodyStringRepresentation(_ body: llvm.StringRef)
    mutating func isBodyTypeChecked() -> Bool
    mutating func isBodySkipped() -> Bool
    mutating func isMemberwiseInitializer() -> Bool

    /// For a method of a class, checks whether it will require a new entry in the
    /// vtable.
    mutating func needsNewVTableEntry() -> Bool
    mutating func isSynthesized() -> Bool
    mutating func setSynthesized(_ value: Bool)

    /// Retrieve the source range of the function body.
    mutating func getBodySourceRange() -> swift.SourceRange

    /// Keep current \c getBodySourceRange() as the "original" body source range
    /// iff the this method hasn't been called on this object. The current body
    /// source range must be in the same buffer as the location of the declaration
    /// itself.
    mutating func keepOriginalBodySourceRange()

    /// Retrieve the source range of the *original* function body.
    ///
    /// This may be different from \c getBodySourceRange() that returns the source
    /// range of the *current* body. It happens when the body is parsed from other
    /// source buffers for e.g. code-completion.
    mutating func getOriginalBodySourceRange() -> swift.SourceRange

    /// Retrieve the source range of the function declaration name + patterns.
    mutating func getSignatureSourceRange() -> swift.SourceRange
    mutating func getCaptureInfo() -> swift.CaptureInfo
    mutating func setCaptureInfo(_ captures: swift.CaptureInfo)

    /// Retrieve the Objective-C selector that names this method.
    mutating func getObjCSelector(_ preferredName: swift.DeclName, _ skipIsObjCResolution: Bool) -> swift.ObjCSelector

    /// Determine whether the given method would produce an Objective-C
    /// instance method.
    mutating func isObjCInstanceMethod() -> Bool

    /// Determine whether the name of an argument is an API name by default
    /// depending on the function context.
    mutating func argumentNameIsAPIByDefault() -> Bool

    /// Retrieve the function's parameter list, not including 'self' if present.
    mutating func getParameters() -> OpaquePointer!
    mutating func getParameters() -> OpaquePointer!
    mutating func setParameters(_ Params: OpaquePointer!)
    mutating func hasImplicitSelfDecl() -> Bool

    /// Constructors and destructors always have a 'self' parameter,
    /// which is stored in an instance member. Functions only have a
    /// 'self' if they are declared inside of a nominal type or extension,
    /// in which case we tail-allocate storage for it.
    mutating func getImplicitSelfDeclStorage() -> UnsafeMutablePointer<UnsafeMutablePointer<swift.ParamDecl>?>!

    /// Retrieve the implicit 'self' parameter for methods. Returns nullptr for
    /// free functions.
    mutating func getImplicitSelfDecl(_ createIfNeeded: Bool) -> UnsafePointer<swift.ParamDecl>!
    mutating func getImplicitSelfDecl(_ createIfNeeded: Bool) -> UnsafeMutablePointer<swift.ParamDecl>!

    /// Retrieve the declaration that this method overrides, if any.
    mutating func getOverriddenDecl() -> UnsafeMutablePointer<swift.AbstractFunctionDecl>!

    /// Whether the declaration is later overridden in the module
    ///
    /// Overrides are resolved during type checking; only query this field after
    /// the whole module has been checked
    mutating func isOverridden() -> Bool

    /// The declaration has been overridden in the module
    ///
    /// Resolved during type checking
    mutating func setIsOverridden()

    /// If this is a foreign C function imported as a method, get the index of
    /// the foreign parameter imported as `self`. If the function is imported
    /// as a static method, `-1` is returned to represent the `self` parameter
    /// being dropped altogether. `None` is returned for a normal function
    /// or method.
    mutating func getForeignFunctionAsMethodSelfParameterIndex() -> llvm.__CxxTemplateInstN4llvm8OptionalIiEE
    static func classof(_ D: UnsafePointer<swift.Decl>!) -> Bool
    static func classof(_ DC: UnsafePointer<swift.DeclContext>!) -> Bool

    /// True if the declaration is forced to be statically dispatched.
    mutating func hasForcedStaticDispatch() -> Bool

    /// Get the type of this declaration without the Self clause.
    /// Asserts if not in type context.
    mutating func getMethodInterfaceType() -> swift.`Type`

    /// Tests if this is a function returning a DynamicSelfType, or a
    /// constructor.
    mutating func hasDynamicSelfResult() -> Bool
  }

  /// Allowed on any instruction.
  struct RegularLocation {
    init(_ S: OpaquePointer!)
    init(_ E: OpaquePointer!)
    init(_ D: UnsafeMutablePointer<swift.Decl>!)
    init(_ P: OpaquePointer!)
    init(_ L: swift.SourceLoc)
    init(_ L: swift.SILLocation.DebugLoc)

    /// Returns a location representing the module.
    static func getModuleLocation() -> swift.RegularLocation

    /// If the current value is of the specified AST unit type T,
    /// return it, otherwise return null.
    mutating func getAs<T>() -> OpaquePointer!

    /// Returns true if the Location currently points to the AST node
    /// matching type T.
    mutating func `is`<T>() -> Bool

    /// Returns the primary value as the specified AST node type. If the
    /// specified type is incorrect, asserts.
    mutating func castTo<T>() -> OpaquePointer!

    /// Compiler-generated locations may be applied to instructions without any
    /// clear correspondence to an AST node in an otherwise normal function.
    /// The auto-generated bit also turns off certain diagnostics passes such.
    static func getAutoGeneratedLocation() -> swift.RegularLocation

    /// Returns a location that is compiler-generated, but wi