Add indirect branches

Author: CodaFi

Sources/LLVM/BasicBlock.swift

@@ -86,3 +86,20 @@ public struct BasicBlock: IRValue {
     LLVMMoveBasicBlockAfter(llvm, block.llvm)
   }
 }
+
+extension BasicBlock {
+  /// A `Address` represents a function-relative address of a basic block for 
+  /// use with the `indirectbr` instruction.
+  public struct Address: IRValue {
+    internal let llvm: LLVMValueRef
+
+    internal init(llvm: LLVMValueRef) {
+      self.llvm = llvm
+    }
+
+    /// Retrieves the underlying LLVM value object.
+    public func asLLVM() -> LLVMValueRef {
+      return llvm
+    }
+  }
+}

Sources/LLVM/Function.swift

@@ -90,6 +90,35 @@ public class Function: IRGlobal {
     }
   }
 
+  /// Computes the address of the specified basic block in this function, and 
+  /// always has an `i8*` type. 
+  ///
+  /// Taking the address of the entry block is illegal.
+  ///
+  /// This value only has defined behavior when used as an operand to the 
+  /// `indirectbr` instruction, or for comparisons against null. Pointer 
+  /// equality tests between labels addresses results in undefined behavior 
+  /// — though, again, comparison against null is ok, and no label is equal to 
+  /// the null pointer. This may be passed around as an opaque pointer sized 
+  /// value as long as the bits are not inspected. This allows `ptrtoint` and 
+  /// arithmetic to be performed on these values so long as the original value 
+  /// is reconstituted before the indirectbr instruction.
+  ///
+  /// Finally, some targets may provide defined semantics when using the value 
+  /// as the operand to an inline assembly, but that is target specific.
+  ///
+  /// - parameter block: The basic block to compute the address of.
+  ///
+  /// - returns: An IRValue representing the address of the given basic block
+  ///   in this function, else nil if the address cannot be computed or the 
+  ///   basic block does not reside in this function. 
+  public func address(of block: BasicBlock) -> BasicBlock.Address? {
+    guard let addr = LLVMBlockAddress(llvm, block.llvm) else {
+      return nil
+    }
+    return BasicBlock.Address(llvm: addr)
+  }
+
   /// Retrieves the previous function in the module, if there is one.
   public func previous() -> Function? {
     guard let previous = LLVMGetPreviousFunction(llvm) else { return nil }

Sources/LLVM/IRBuilder.swift

@@ -864,6 +864,25 @@ public class IRBuilder {
     return LLVMBuildCondBr(llvm, condition.asLLVM(), then.asLLVM(), `else`.asLLVM())
   }
 
+  /// Build an indirect branch to a label within the current function.
+  ///
+  /// - parameter address: The address of the label to branch to.
+  /// - parameter destinations: The set of possible destinations the address may
+  ///   point to.  The same block may appear multiple times in this list, though
+  ///   this isn't particularly useful.
+  ///
+  /// - returns: An IRValue representing `void`.
+  @discardableResult
+  public func buildIndirectBr(address: BasicBlock.Address, destinations: [BasicBlock]) -> IRValue {
+    guard let ret = LLVMBuildIndirectBr(llvm, address.asLLVM(), UInt32(destinations.count)) else {
+      fatalError("Unable to build indirect branch to address \(address)")
+    }
+    for dest in destinations {
+      LLVMAddDestination(ret, dest.llvm)
+    }
+    return ret
+  }
+
   /// Builds a return from the current function back to the calling function
   /// with the given value.
   ///