Added context to all types

Author: vdka

Sources/LLVM/ArrayType.swift

@@ -12,6 +12,7 @@ public struct ArrayType: IRType {
   public let count: Int
 
   /// Creates an array type from an underlying element type and count.
+  /// - note: The context of this type is taken from it's `elementType`
   public init(elementType: IRType, count: Int) {
     self.elementType = elementType
     self.count = count

Sources/LLVM/FloatType.swift

@@ -4,19 +4,51 @@ import cllvm
 
 /// `FloatType` enumerates representations of a floating value of a particular
 /// bit width and semantics.
-public enum FloatType: IRType {
-  /// 16-bit floating point value
-  case half
-  /// 32-bit floating point value
-  case float
-  /// 64-bit floating point value
-  case double
-  /// 80-bit floating point value (X87)
-  case x86FP80
-  /// 128-bit floating point value (112-bit mantissa)
-  case fp128
-  /// 128-bit floating point value (two 64-bits)
-  case ppcFP128
+public struct FloatType: IRType {
+
+  /// The kind of floating point type this is
+  public var kind: Kind
+
+  /// Returns the context associated with this module.
+  public let context: Context?
+
+  /// Creates a float type of a particular kind
+  ///
+  /// - parameter kind: The kind of floating point type to create
+  /// - parameter context: The context to create this type in
+  /// - SeeAlso: http://llvm.org/docs/ProgrammersManual.html#achieving-isolation-with-llvmcontext
+  public init(kind: Kind, in context: Context? = nil) {
+    self.kind = kind
+    self.context = context
+  }
+
+  public enum Kind {
+    /// 16-bit floating point value
+    case half
+    /// 32-bit floating point value
+    case float
+    /// 64-bit floating point value
+    case double
+    /// 80-bit floating point value (X87)
+    case x86FP80
+    /// 128-bit floating point value (112-bit mantissa)
+    case fp128
+    /// 128-bit floating point value (two 64-bits)
+    case ppcFP128
+  }
+
+  /// 16-bit floating point value in the global context
+  static let half = FloatType(kind: .half)
+  /// 32-bit floating point value in the global context
+  static let float = FloatType(kind: .float)
+  /// 64-bit floating point value in the global context
+  static let double = FloatType(kind: .double)
+  /// 80-bit floating point value (X87) in the global context
+  static let x86FP80 = FloatType(kind: .x86FP80)
+  /// 128-bit floating point value (112-bit mantissa) in the global context
+  static let fp128 = FloatType(kind: .fp128)
+  /// 128-bit floating point value (two 64-bits) in the global context
+  static let ppcFP128 = FloatType(kind: .ppcFP128)
 
   /// Creates a constant floating value of this type from a Swift `Double` value.
   public func constant(_ value: Double) -> Constant<Floating> {
@@ -25,7 +57,17 @@ public enum FloatType: IRType {
 
   /// Retrieves the underlying LLVM type object.
   public func asLLVM() -> LLVMTypeRef {
-    switch self {
+    if let context = context {
+        switch kind {
+        case .half: return LLVMHalfTypeInContext(context.llvm)
+        case .float: return LLVMFloatTypeInContext(context.llvm)
+        case .double: return LLVMDoubleTypeInContext(context.llvm)
+        case .x86FP80: return LLVMX86FP80TypeInContext(context.llvm)
+        case .fp128: return LLVMFP128TypeInContext(context.llvm)
+        case .ppcFP128: return LLVMPPCFP128TypeInContext(context.llvm)
+        }
+    }
+    switch kind {
     case .half: return LLVMHalfType()
     case .float: return LLVMFloatType()
     case .double: return LLVMDoubleType()

Sources/LLVM/FunctionType.swift

@@ -20,6 +20,7 @@ public struct FunctionType: IRType {
   /// - parameter returnType: The return type of the function type.
   /// - parameter isVarArg: Indicates whether this function type is variadic.
   ///   Defaults to `false`.
+  /// - note: The context of this type is taken from it's `returnType`
   public init(argTypes: [IRType], returnType: IRType, isVarArg: Bool = false) {
     self.argTypes = argTypes
     self.returnType = returnType

Sources/LLVM/IntType.swift

@@ -11,8 +11,18 @@ public struct IntType: IRType {
   /// Retrieves the bit width of this integer type.
   public let width: Int
 
+  /// Returns the context associated with this module.
+  public let context: Context?
+
   /// Creates an integer type with the specified bit width.
-  public init(width: Int) { self.width = width }
+  ///
+  /// - parameter width: The width in bits of the integer type
+  /// - parameter context: The context to create this type in
+  /// - SeeAlso: http://llvm.org/docs/ProgrammersManual.html#achieving-isolation-with-llvmcontext
+  public init(width: Int, in context: Context? = nil) {
+    self.width = width
+    self.context = context
+  }
 
   /// Retrieves the `i1` type.
   public static let int1 = IntType(width: 1)
@@ -68,6 +78,9 @@ public struct IntType: IRType {
 
   /// Retrieves the underlying LLVM type object.
   public func asLLVM() -> LLVMTypeRef {
+    if let context = context {
+        return LLVMIntTypeInContext(context.llvm, UInt32(width))
+    }
     return LLVMIntType(UInt32(width))
   }
 }

Sources/LLVM/PointerType.swift

@@ -23,6 +23,7 @@ public struct PointerType: IRType {
   /// - parameter pointee: The type of the pointed-to object.
   /// - parameter addressSpace: The optional address space where the pointed-to
   ///   object resides.
+  /// - note: The context of this type is taken from it's pointee
   public init(pointee: IRType, addressSpace: Int = 0) {
     // FIXME: This class of invalid reference is not caught by Module.verify(),
     // only `lli`.

Sources/LLVM/StructType.swift

@@ -35,10 +35,16 @@ public struct StructType: IRType {
   /// - parameter elementTypes: A list of types of members of this structure.
   /// - parameter isPacked: Whether or not this structure is 1-byte aligned with
   ///   no packing between fields.  Defaults to `false`.
-  public init(elementTypes: [IRType], isPacked: Bool = false) {
+  /// - parameter context: The context to create this type in
+  /// - SeeAlso: http://llvm.org/docs/ProgrammersManual.html#achieving-isolation-with-llvmcontext
+  public init(elementTypes: [IRType], isPacked: Bool = false, in context: Context? = nil) {
     var irTypes = elementTypes.map { $0.asLLVM() as Optional }
     self.llvm = irTypes.withUnsafeMutableBufferPointer { buf in
-      LLVMStructType(buf.baseAddress, UInt32(buf.count), isPacked.llvm)
+      if let context = context {
+        return LLVMStructTypeInContext(context.llvm, buf.baseAddress, UInt32(buf.count), isPacked.llvm)
+      } else {
+        return LLVMStructType(buf.baseAddress, UInt32(buf.count), isPacked.llvm)
+      }
     }
   }
 

Sources/LLVM/VectorType.swift

@@ -16,6 +16,7 @@ public struct VectorType: IRType {
   ///
   /// - parameter elementType: The type of elements of this vector.
   /// - parameter count: The number of elements in this vector.
+  /// - note: The context of this type is taken from it's `elementType`
   public init(elementType: IRType, count: Int) {
     self.elementType = elementType
     self.count = count

Sources/LLVM/VoidType.swift

@@ -4,11 +4,23 @@ import cllvm
 
 /// The `Void` type represents any value and has no size.
 public struct VoidType: IRType {
+
+  /// Returns the context associated with this module.
+  public let context: Context?
+
   /// Creates an instance of the `Void` type.
-  public init() {}
+  ///
+  /// - parameter context: The context to create this type in
+  /// - SeeAlso: http://llvm.org/docs/ProgrammersManual.html#achieving-isolation-with-llvmcontext
+  public init(in context: Context? = nil) {
+    self.context = context
+  }
 
   /// Retrieves the underlying LLVM type object.
   public func asLLVM() -> LLVMTypeRef {
+    if let context = context {
+      return LLVMVoidTypeInContext(context.llvm)
+    }
     return LLVMVoidType()
   }
 }