XXX

Author: CodaFi

Sources/LLVM/ArrayType.swift

@@ -5,7 +5,7 @@ import cllvm
 /// `ArrayType` is a very simple derived type that arranges elements
 /// sequentially in memory. `ArrayType` requires a size (number of elements) and
 /// an underlying data type.
-public struct ArrayType: IRType {
+public struct ArrayType: IRType, DIType {
   /// The type of elements in this array.
   public let elementType: IRType
   /// The number of elements in this array.
@@ -34,4 +34,29 @@ public struct ArrayType: IRType {
   public func asLLVM() -> LLVMTypeRef {
     return LLVMArrayType(elementType.asLLVM(), UInt32(count))
   }
+
+  public func asMetadata(with builder: DIBuilder) -> LLVMMetadataRef {
+    let elemDITy : LLVMMetadataRef
+    if let elemDI = self.elementType as? DIType {
+      elemDITy = elemDI.asMetadata(with: builder)
+    } else {
+      elemDITy = LLVMDIBuilderCreateUnspecifiedType(builder.llvm, "<unspecified>")
+    }
+
+    var type : IRType = self
+    var subscripts : [LLVMMetadataRef?] = []
+    while let arrTy = type as? ArrayType {
+      subscripts.append(LLVMDIBuilderGetOrCreateSubrange(builder.llvm, 0, Int64(arrTy.count)))
+      type = arrTy.elementType
+    }
+
+    return subscripts.withUnsafeMutableBufferPointer { buf in
+      return LLVMDIBuilderCreateArrayType(
+        builder.llvm, UInt64(self.count),
+        UInt32(builder.module.dataLayout.abiAlignment(of: self)),
+        elemDITy, buf.baseAddress!, UInt32(subscripts.count)
+      )
+    }
+  }
+
 }

Sources/LLVM/DIBuilder.swift

@@ -534,6 +534,14 @@ public struct DICompileUnit: Metadata {
   }
 }
 
+public struct DIExpression: Metadata {
+  internal let llvm: LLVMMetadataRef
+
+  public func asMetadata() -> LLVMMetadataRef {
+    return llvm
+  }
+}
+
 
 public struct DebugLocation: Metadata {
   internal let llvm: LLVMMetadataRef
@@ -600,14 +608,12 @@ public final class DIBuilder {
   }
 
   /// Insert a new llvm.dbg.value intrinsic call.
-  // FIXME: complex address expression?
-  public func insertDebugValueIntrinsicAtEnd(for value: IRValue, at offset: Int, with info: VariableMetadata, at loc: DebugLocation, in bb: BasicBlock, expr: Metadata? = nil) {
+  public func insertDebugValueIntrinsicAtEnd(for value: IRValue, at offset: Int, with info: VariableMetadata, at loc: DebugLocation, in bb: BasicBlock, expr: DIExpression? = nil) {
     LLVMDIBuilderInsertDbgValueIntrinsicAtEnd(self.llvm, value.asLLVM(), UInt64(offset), info.llvm, expr?.asMetadata(), loc.llvm, bb.asLLVM())
   }
 
   /// Insert a new llvm.dbg.value intrinsic call.
-  // FIXME: complex address expression?
-  public func insertDebugValueIntrinsicBefore(for value: IRValue, at offset: Int, with info: VariableMetadata, at loc: DebugLocation, in bb: BasicBlock, expr: Metadata? = nil) {
+  public func insertDebugValueIntrinsicBefore(for value: IRValue, at offset: Int, with info: VariableMetadata, at loc: DebugLocation, in bb: BasicBlock, expr: DIExpression? = nil) {
     LLVMDIBuilderInsertDbgValueIntrinsicBefore(self.llvm, value.asLLVM(), UInt64(offset), info.llvm, expr?.asMetadata(), loc.llvm, bb.asLLVM())
   }
 
@@ -674,6 +680,28 @@ public final class DIBuilder {
     return VariableMetadata(llvm: vari)
   }
 
+  /// Create debugging information entry for a struct.
+  public func createStructType(for type: StructType, in scope: Scope, in file: FileMetadata, at line: Int, flags: DebugInfoFlags = .zero, uniqueID: String) -> Metadata {
+    var elemMetadata = type.elementTypes.map { (ty) -> LLVMMetadataRef? in
+      if let elemDI = ty as? DIType {
+        return elemDI.asMetadata(with: self)
+      } else {
+        return LLVMDIBuilderCreateUnspecifiedType(self.llvm, "<unspecified>")
+      }
+    }
+
+    return elemMetadata.withUnsafeMutableBufferPointer { buf in
+      return AnyMetadata(llvm:
+        LLVMDIBuilderCreateStructType(
+          self.llvm, scope.llvm, type.name, file.llvm, UInt32(line),
+          UInt64(self.module.dataLayout.sizeOfTypeInBits(type)),
+          UInt32(self.module.dataLayout.abiAlignment(of: type)),
+          flags.llvm, nil,
+          buf.baseAddress, UInt32(elemMetadata.count),
+          0, nil, uniqueID
+      ))
+    }
+  }
 
   /// Construct any deferred debug info descriptors.
   public func finalize() {
@@ -828,21 +856,6 @@ public func LLVMDIBuilderCreateBasicType(_ Builder: LLVMDIBuilderRef!, _ Name: U
 /// \param Name              Pointer type name. (optional)
 public func LLVMDIBuilderCreatePointerType(_ Builder: LLVMDIBuilderRef!, _ PointeeTy: LLVMMetadataRef!, _ SizeInBits: UInt64, _ AlignInBits: UInt32, _ AddressSpace: UInt32, _ Name: UnsafePointer<Int8>!) -> LLVMMetadataRef!
 
-/// Create debugging information entry for a struct.
-/// \param Builder     The DIBuilder.
-/// \param Scope        Scope in which this struct is defined.
-/// \param Name         Struct name.
-/// \param File         File where this member is defined.
-/// \param LineNumber   Line number.
-/// \param SizeInBits   Member size.
-/// \param AlignInBits  Member alignment.
-/// \param Flags        Flags to encode member attribute, e.g. private
-/// \param Elements     Struct elements.
-/// \param RunTimeLang  Optional parameter, Objective-C runtime version.
-/// \param VTableHolder The object containing the vtable for the struct.
-/// \param UniqueIdentifier A unique identifier for the struct.
-public func LLVMDIBuilderCreateStructType(_ Builder: LLVMDIBuilderRef!, _ Scope: LLVMMetadataRef!, _ Name: UnsafePointer<Int8>!, _ File: LLVMMetadataRef!, _ LineNumber: UInt32, _ SizeInBits: UInt64, _ AlignInBits: UInt32, _ Flags: LLVMDIFlags, _ DerivedFrom: LLVMMetadataRef!, _ Elements: UnsafeMutablePointer<LLVMMetadataRef?>!, _ NumElements: UInt32, _ RunTimeLang: UInt32, _ VTableHolder: LLVMMetadataRef!, _ UniqueId: UnsafePointer<Int8>!) -> LLVMMetadataRef!
-
 /// Create debugging information entry for a member.
 /// \param Builder      The DIBuilder.
 /// \param Scope        Member scope.

Sources/LLVM/FloatType.swift

@@ -52,8 +52,7 @@ public enum FloatType: IRType, DIType {
       name = "ppcfloat128"
     }
     return LLVMDIBuilderCreateBasicType(
-      builder.llvm,
-      name,
+      builder.llvm, name,
       UInt64(builder.module.dataLayout.sizeOfTypeInBits(self)),
       DWARFTypeEncoding.float.llvm
     )

Sources/LLVM/IntType.swift

@@ -7,7 +7,7 @@ import cllvm
 /// The `IntType` is a very simple type that simply specifies an arbitrary bit
 /// width for the integer type desired. Any bit width from 1 bit to (2^23)-1
 /// (about 8 million) can be specified.
-public struct IntType: IRType {
+public struct IntType: IRType, DIType {
   /// Retrieves the bit width of this integer type.
   public let width: Int
 
@@ -70,4 +70,11 @@ public struct IntType: IRType {
   public func asLLVM() -> LLVMTypeRef {
     return LLVMIntType(UInt32(width))
   }
+
+  public func asMetadata(with builder: DIBuilder) -> LLVMMetadataRef {
+    return LLVMDIBuilderCreateBasicType(
+      builder.llvm, "int\(self.width)",
+      UInt64(self.width), DWARFTypeEncoding.signed.llvm
+    )
+  }
 }

Sources/LLVM/PointerType.swift

@@ -12,7 +12,7 @@ import cllvm
 ///
 /// Note that LLVM does not permit pointers to void `(void*)` nor does it permit
 /// pointers to labels `(label*)`.  Use `i8*` instead.
-public struct PointerType: IRType {
+public struct PointerType: IRType, DIType {
   /// Retrieves the type of the value being pointed to.
   public let pointee: IRType
   /// Retrieves the address space where the pointed-to object resides.
@@ -35,4 +35,20 @@ public struct PointerType: IRType {
   public func asLLVM() -> LLVMTypeRef {
     return LLVMPointerType(pointee.asLLVM(), UInt32(addressSpace))
   }
+
+  public func asMetadata(with builder: DIBuilder) -> LLVMMetadataRef {
+    let pointeeTy : LLVMMetadataRef
+    if let pointeeDI = self.pointee as? DIType {
+      pointeeTy = pointeeDI.asMetadata(with: builder)
+    } else {
+      pointeeTy = LLVMDIBuilderCreateUnspecifiedType(builder.llvm, "<unspecified>")
+    }
+    return LLVMDIBuilderCreatePointerType(
+      builder.llvm, pointeeTy,
+      UInt64(builder.module.dataLayout.sizeOfTypeInBits(self)),
+      UInt32(builder.module.dataLayout.abiAlignment(of: self)),
+      UInt32(self.addressSpace),
+      "PointerType"
+    )
+  }
 }

Sources/LLVM/VectorType.swift

@@ -6,7 +6,7 @@ import cllvm
 /// elements. `VectorType`s are used when multiple primitive data are operated
 /// in parallel using a single instruction (SIMD). A vector type requires a size
 /// (number of elements) and an underlying primitive data type.
-public struct VectorType: IRType {
+public struct VectorType: IRType, DIType {
   /// Returns the type of elements in the vector.
   public let elementType: IRType
   /// Returns the number of elements in the vector.
@@ -25,4 +25,21 @@ public struct VectorType: IRType {
   public func asLLVM() -> LLVMTypeRef {
     return LLVMVectorType(elementType.asLLVM(), UInt32(count))
   }
+
+  public func asMetadata(with builder: DIBuilder) -> LLVMMetadataRef {
+    let elemDITy : LLVMMetadataRef
+    if let elemDI = self.elementType as? DIType {
+      elemDITy = elemDI.asMetadata(with: builder)
+    } else {
+      elemDITy = LLVMDIBuilderCreateUnspecifiedType(builder.llvm, "<unspecified>")
+    }
+
+    var ranges : [LLVMMetadataRef?] = [ LLVMDIBuilderGetOrCreateSubrange(builder.llvm, 0, Int64(self.count)).asLLVM() ]
+    return ranges.withUnsafeMutableBufferPointer { buf in
+      return LLVMDIBuilderCreateVectorType(
+        builder.llvm, UInt64(self.count),
+        UInt32(builder.module.dataLayout.abiAlignment(of: self)),
+        elemDITy, buf.baseAddress!, UInt32(ranges.count))
+    }
+  }
 }