 
   /// Build an unconditional branch to the given basic block.
   ///
+  /// The `br` instruction is used to cause control flow to transfer to a
+  /// different basic block in the current function. There are two forms of this
+  /// instruction, corresponding to a conditional branch and an unconditional
+  /// branch.  To build a conditional branch, see
+  /// `buildCondBr(condition:then:`else`:)`.
+  ///
   /// - parameter block: The target block to transfer control flow to.
   ///
   /// - returns: A value representing `void`.

  /// Build a branch table that branches on the given value with the given
  /// default basic block.
  ///
  /// The ‘switch‘ instruction is used to transfer control flow to one of
  /// several different places. It is a generalization of the ‘br‘ instruction,
  /// allowing a branch to occur to one of many possible destinations.
  ///
  /// - parameter value: The value to compare.
  /// - parameter else: The default destination for control flow should the


  /// Build a fence instruction that introduces "happens-before" edges between
  /// operations.
  ///
  /// A fence `A` which has (at least) `release` ordering semantics synchronizes
  /// with a fence `B` with (at least) `acquire` ordering semantics if and only
  /// if there exist atomic operations X and Y, both operating on some atomic
  /// object `M`, such that `A` is sequenced before `X`, `X` modifies `M`
  /// (either directly or through some side effect of a sequence headed by `X`),
  /// `Y` is sequenced before `B`, and `Y` observes `M`. This provides a
  /// happens-before dependency between `A` and `B`. Rather than an explicit
  /// fence, one (but not both) of the atomic operations `X` or `Y` might
  /// provide a release or acquire (resp.) ordering constraint and still
  /// synchronize-with the explicit fence and establish the happens-before edge.
  ///
  /// A fence which has `sequentiallyConsistent` ordering, in addition to having
  /// both `acquire` and `release` semantics specified above, participates in
  /// the global program order of other `sequentiallyConsistent` operations
  /// and/or fences.
  ///
  /// - parameter ordering: Defines the kind of "synchronizes-with" edge this
  ///   fence adds.
