XXX

Author: CodaFi

Sources/LLVM/DIBuilder.swift

@@ -1,4 +1,4 @@
-#if !NO_SWIFTPM
+#if SWIFT_PACKAGE
 import cllvm
 #endif
 
@@ -584,8 +584,11 @@ public final class DIBuilder {
 
   /// Creates a new DebugLocation that describes a source location.
   public func createDebugLocation(at loc : (line: Int, column: Int), in scope: Scope, inlinedAt: Scope? = nil) -> DebugLocation {
-    guard let loc = LLVMDIBuilderCreateDebugLocation(self.module.context.llvm, UInt32(loc.line), UInt32(loc.column), scope.llvm, inlinedAt?.llvm) else {
-      fatalError()
+    guard let loc = LLVMDIBuilderCreateDebugLocation(
+      self.module.context.llvm, UInt32(loc.line), UInt32(loc.column),
+      scope.llvm, inlinedAt?.llvm
+    ) else {
+      fatalError("Failed to allocate metadata for a debug location")
     }
     return DebugLocation(llvm: loc)
   }
@@ -610,14 +613,18 @@ public final class DIBuilder {
   }
 
   /// Create a file descriptor to hold debugging information for a file.
-  public func createFile(named name: String, in directory: String) -> FileMetadata? {
-    guard let file = LLVMDIBuilderCreateFile(self.llvm, name, directory) else { return nil }
+  public func createFile(named name: String, in directory: String) -> FileMetadata {
+    guard let file = LLVMDIBuilderCreateFile(self.llvm, name, directory) else {
+      fatalError("Failed to allocate metadata for a file")
+    }
     return FileMetadata(llvm: file)
   }
 
   /// Create debugging information temporary entry for a macro file.
-  public func createTemporaryMacroFile(at line: UInt32, in file: FileMetadata, withParent parent: FileMetadata? = nil) -> FileMetadata? {
-    guard let file = LLVMDIBuilderCreateTempMacroFile(self.llvm, parent?.llvm, line, file.llvm) else { return nil }
+  public func createTemporaryMacroFile(at line: Int, in file: FileMetadata, withParent parent: FileMetadata? = nil) -> FileMetadata {
+    guard let file = LLVMDIBuilderCreateTempMacroFile(self.llvm, parent?.llvm, UInt32(line), file.llvm) else {
+      fatalError("Failed to allocate metadata for a temporary macro file")
+    }
     return FileMetadata(llvm: file)
   }
 
@@ -654,17 +661,68 @@ public final class DIBuilder {
         isOptimized ? 1 : 0,
         body.llvm, nil, 0, nil
       ) else {
-          fatalError()
+          fatalError("Failed to allocate metadata for a function")
       }
       return Scope(llvm: gn)
     }
   }
 
+  /// Identical to LLVMDIBuilderCreateFunction,
+  /// except that the resulting DbgNode is meant to be RAUWed.
+  public func createTemporaryFunctionForwardDeclaration(
+    in scope: Scope, named name: String, linkageName mangled: String,
+    in file: FileMetadata, at line: Int, body: Function,
+    isLocal: Bool, isDefinition: Bool,
+    scopeLine: Int,
+    flags: DebugInfoFlags = .zero,
+    isOptimized: Bool = false
+  ) -> Scope {
+    // HACK: Functions come in as function pointers.
+    let bodyTy: FunctionType
+    if let pfty = body.type as? PointerType, pfty.pointee is FunctionType {
+      bodyTy = pfty.pointee as! FunctionType
+    } else {
+      bodyTy = body.type as! FunctionType
+    }
+    var elemMetadata = bodyTy.argTypes.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
+      let fnTy = LLVMDIBuilderCreateSubroutineType(self.llvm, file.llvm, buf.baseAddress!, UInt32(elemMetadata.count))
+      guard let tffd = LLVMDIBuilderCreateTempFunctionFwdDecl(
+        self.llvm, scope.llvm, name, mangled, file.llvm, UInt32(line), fnTy,
+        isLocal ? 1 : 0,
+        isDefinition ? 1 : 0,
+        UInt32(scopeLine), flags.llvm,
+        isOptimized ? 1 : 0,
+        body.llvm, nil, 0, nil
+      ) else {
+        fatalError("Failed to allocate metadata for a temporary forward declaration")
+      }
+      return Scope(llvm: tffd)
+    }
+  }
+
+
+  /// This creates a descriptor for a lexical block with a new file
+  /// attached. This merely extends the existing
+  /// lexical block as it crosses a file.
+  public func createLexicalBlockFile(in scope: Scope, in file: FileMetadata) -> Scope {
+    guard let scope = LLVMDIBuilderCreateLexicalBlockFile(self.llvm, scope.llvm, file.llvm) else {
+      fatalError("Failed to allocate metadata for a lexical block file extension")
+    }
+    return Scope(llvm: scope)
+  }
+
   /// This creates a descriptor for a lexical block with the
   /// specified parent context.
   public func createLexicalBlock(in scope: Scope, in file: FileMetadata, at loc : (line: Int, column: Int)) -> Scope {
     guard let scope = LLVMDIBuilderCreateLexicalBlock(self.llvm, scope.llvm, file.llvm, UInt32(loc.line), UInt32(loc.column)) else {
-      fatalError()
+      fatalError("Failed to allocate metadata for a lexical block")
     }
     return Scope(llvm: scope)
   }
@@ -673,35 +731,56 @@ public final class DIBuilder {
   /// parent scope.
   public func createModule(in scope: Scope, named name: String, macros: [String], include ipath: String, _ isysRoot: String) -> DIModule {
     guard let module = LLVMDIBuilderCreateModule(self.llvm, scope.llvm, name, macros.joined(separator: " "), ipath, isysRoot) else {
-      fatalError()
+      fatalError("Failed to allocate metadata for a module")
     }
     return DIModule(llvm: module)
   }
 
   /// Create debugging information entry for a macro.
-  public func createMacro(in parent: FileMetadata, at line: Int, type macroTy: MachineInfoRecordType, name: String) -> Macro! {
+  public func createMacro(in parent: FileMetadata, at line: Int, type macroTy: MachineInfoRecordType, name: String) -> Macro {
     guard let macro = LLVMDIBuilderCreateMacro(self.llvm, parent.asMetadata(), UInt32(line), macroTy.rawValue, name) else {
-      fatalError()
+      fatalError("Failed to allocate metadata for a macro")
     }
     return Macro(llvm: macro)
   }
 
   /// Create debugging information entry for a typedef.
   public func createTypedef(of type: DIType, named name: String, in file: FileMetadata, at line: Int, in scope: Scope) -> DIType {
     guard let typedef = LLVMDIBuilderCreateTypedef(self.llvm, type.asMetadata(with: self), name, file.llvm, UInt32(line), scope.llvm) else {
-      fatalError()
+      fatalError("Failed to allocate metadata for a typedef")
     }
     return AnyDIType(llvm: typedef)
   }
 
   /// Create a new DIType with "artificial" flag set.
   public func createArtificialType(of type: DIType) -> DIType {
     guard let ty = LLVMDIBuilderCreateArtificialType(self.llvm, type.asMetadata(with: self)) else {
-      fatalError()
+      fatalError("Failed to allocate metadata for an artificial type")
     }
     return AnyDIType(llvm: ty)
   }
 
+  /// Create a permanent forward-declared type.
+  public func createForwardDecl(in scope: Scope, named name: String, in file: FileMetadata, at line: Int, tag: Int) -> DIType {
+    guard let fd = LLVMDIBuilderCreateForwardDecl(self.llvm, UInt32(tag), name, scope.llvm, file.llvm, UInt32(line)) else {
+      fatalError("Failed to allocate metadata for a forward declaration")
+    }
+    return AnyDIType(llvm: fd)
+  }
+
+  /// Create a new descriptor for a parameter variable.
+  public func createParameterVariable(in scope: Scope, named name: String, at index: UInt32, in file: FileMetadata, at line: Int, type: DIType, _ alwaysPreserve: Bool = true, flags: DebugInfoFlags = .zero) -> VariableMetadata {
+    guard let pv = LLVMDIBuilderCreateParameterVariable(
+      self.llvm, scope.llvm, name, UInt32(index), file.llvm, UInt32(line),
+      type.asMetadata(with: self),
+      alwaysPreserve ? 1 : 0, flags.llvm
+    ) else {
+      fatalError("Failed to allocate metadata for a parameter variable")
+    }
+    return VariableMetadata(llvm: pv)
+  }
+
+
   /// Create a new descriptor for an auto variable.  This is a local variable
   /// that is not a subprogram parameter.
   public func createAutoVariable(in scope: Scope, named name: String, in file: FileMetadata, at line: Int, type: DIType, alwaysPreserve: Bool, flags: DebugInfoFlags, aligned alignInBits: Int) -> VariableMetadata {
@@ -718,7 +797,7 @@ public final class DIBuilder {
   }
 
   /// Create debugging information entry for a struct.
-  public func createStructType(for type: StructType, in scope: Scope, in file: FileMetadata, at line: Int, flags: DebugInfoFlags = DebugInfoFlags.zero, uniqueID: String) -> Metadata {
+  public func createStructType(for type: StructType, in scope: Scope, in file: FileMetadata, at line: Int, flags: DebugInfoFlags = DebugInfoFlags.zero, uniqueID: String) -> DIType {
     var elemMetadata = type.elementTypes.map { (ty) -> LLVMMetadataRef? in
       if let elemDI = ty as? DIType {
         return elemDI.asMetadata(with: self)
@@ -728,7 +807,7 @@ public final class DIBuilder {
     }
 
     return elemMetadata.withUnsafeMutableBufferPointer { buf in
-      return AnyMetadata(llvm:
+      return AnyDIType(llvm:
         LLVMDIBuilderCreateStructType(
           self.llvm, scope.llvm, type.name, file.llvm, UInt32(line),
           UInt64(self.module.dataLayout.sizeOfTypeInBits(type)),
@@ -752,10 +831,6 @@ public final class DIBuilder {
 
 /*
 
-/// Identical to LLVMDIBuilderCreateFunction,
-/// except that the resulting DbgNode is meant to be RAUWed.
-public func LLVMDIBuilderCreateTempFunctionFwdDecl(_ Builder: LLVMDIBuilderRef!, _ Scope: LLVMMetadataRef!, _ Name: UnsafePointer<Int8>!, _ LinkageName: UnsafePointer<Int8>!, _ File: LLVMMetadataRef!, _ LineNo: UInt32, _ Ty: LLVMMetadataRef!, _ IsLocalToUnit: UInt8, _ IsDefinition: UInt8, _ ScopeLine: UInt32, _ Flags: LLVMDIFlags, _ IsOptimized: UInt8, _ Fn: LLVMValueRef!, _ TemplateParams: UnsafeMutablePointer<LLVMMetadataRef?>!, _ NumTemplateParams: UInt32, _ Decl: LLVMMetadataRef!) -> LLVMMetadataRef!
-
 /// Create debugging information entry for a class.
 /// \param Scope        Scope in which this class is defined.
 /// \param Name         class name.
@@ -799,9 +874,6 @@ public func LLVMDIBuilderCreateGlobalVariableExpression(_ Builder: LLVMDIBuilder
 /// \param Type                Parent type.
 public func LLVMDIBuilderCreateBitFieldMemberType(_ Builder: LLVMDIBuilderRef!, _ Scope: LLVMMetadataRef!, _ Name: UnsafePointer<Int8>!, _ File: LLVMMetadataRef!, _ LineNumber: UInt32, _ SizeInBits: UInt64, _ OffsetInBits: UInt64, _ StorageOffsetInBits: UInt64, _ Flags: LLVMDIFlags, _ Type: LLVMMetadataRef!) -> LLVMMetadataRef!
 
-/// Create a permanent forward-declared type.
-public func LLVMDIBuilderCreateForwardDecl(_ Builder: LLVMDIBuilderRef!, _ Tag: UInt32, _ Name: UnsafePointer<Int8>!, _ Scope: LLVMMetadataRef!, _ File: LLVMMetadataRef!, _ Line: UInt32) -> LLVMMetadataRef!
-
 /// Create a new descriptor for the specified C++ method.
 /// See comments in \a DISubprogram* for descriptions of these fields.
 /// \param Scope          Function scope.
@@ -937,63 +1009,6 @@ public func LLVMDIBuilderCreateUnspecifiedParameter(_ Builder: LLVMDIBuilderRef!
 /// Create a DWARF unspecified type.
 public func LLVMDIBuilderCreateUnspecifiedType(_ Builder: LLVMDIBuilderRef!, _ Name: UnsafePointer<Int8>!) -> LLVMMetadataRef!
 
-
-/// Create a new descriptor for a parameter variable.
-///
-/// \c Scope must be a \a DILocalScope, and thus its scope chain eventually
-/// leads to a \a DISubprogram.
-///
-/// \c ArgNo is the index (starting from \c 1) of this variable in the
-/// subprogram parameters.  \c ArgNo should not conflict with other
-/// parameters of the same subprogram.
-///
-/// If \c AlwaysPreserve, this variable will be referenced from its
-/// containing subprogram, and will survive some optimizations.
-public func LLVMDIBuilderCreateParameterVariable(_ Builder: LLVMDIBuilderRef!, _ Scope: LLVMMetadataRef!, _ Name: UnsafePointer<Int8>!, _ ArgNum: UInt32, _ File: LLVMMetadataRef!, _ LineNum: UInt32, _ Type: LLVMMetadataRef!, _ AlwaysPreserve: UInt8, _ Flags: LLVMDIFlags) -> LLVMMetadataRef!
-
-/// This creates a descriptor for a lexical block with a new file
-/// attached. This merely extends the existing
-/// lexical block as it crosses a file.
-/// \param Builder      The DIBuilder.
-/// \param Scope       Lexical block.
-/// \param File        Source file.
-/// \param Discriminator DWARF path discriminator value.
-public func LLVMDIBuilderCreateLexicalBlockFile(_ Builder: LLVMDIBuilderRef!, _ Scope: LLVMMetadataRef!, _ File: LLVMMetadataRef!) -> LLVMMetadataRef!
-
-/// Create an expression for a variable that does not have an address, but
-/// does have a constant value.
-public func LLVMDIBuilderCreateConstantValueExpression(_ Builder: LLVMDIBuilderRef!, _ Val: UInt64) -> LLVMMetadataRef!
-
-/// Create a descriptor to describe one part
-/// of aggregate variable that is fragmented across multiple Values.
-///
-/// \param Builder      The DIBuilder.
-/// \param OffsetInBits Offset of the piece in bits.
-/// \param SizeInBits   Size of the piece in bits.
-public func LLVMDIBuilderCreateFragmentExpression(_ Builder: LLVMDIBuilderRef!, _ OffsetInBits: UInt32, _ SizeInBits: UInt32) -> LLVMMetadataRef!
-
-/// Create a new descriptor for the specified
-/// variable which has a complex address expression for its address.
-/// \param Builder      The DIBuilder.
-/// \param Addrs        One or more complex address operations.
-/// \param NumAddrs     The number of addresses that \c Addrs points to.
-public func LLVMDIBuilderCreateExpression(_ Builder: LLVMDIBuilderRef!, _ Addrs: UnsafeMutablePointer<Int64>!, _ NumAddrs: UInt32) -> LLVMMetadataRef!
-
-/// Create debugging information entry for an array.
-/// \param Builder      The DIBuilder.
-/// \param Size         Array size.
-/// \param AlignInBits  Alignment.
-/// \param Ty           Element type.
-/// \param Subscripts   Subscripts.
-public func LLVMDIBuilderCreateArrayType(_ Builder: LLVMDIBuilderRef!, _ Size: UInt64, _ AlignInBits: UInt32, _ Ty: LLVMMetadataRef!, _ Subscripts: UnsafeMutablePointer<LLVMMetadataRef?>!, _ NumSubscripts: UInt32) -> LLVMMetadataRef!
-
-/// Create debugging information entry for a vector type.
-/// \param Size         Array size.
-/// \param AlignInBits  Alignment.
-/// \param Ty           Element type.
-/// \param Subscripts   Subscripts.
-public func LLVMDIBuilderCreateVectorType(_ Builder: LLVMDIBuilderRef!, _ Size: UInt64, _ AlignInBits: UInt32, _ Ty: LLVMMetadataRef!, _ Subscripts: UnsafeMutablePointer<LLVMMetadataRef?>!, _ NumSubscripts: UInt32) -> LLVMMetadataRef!
-
 /// Create a descriptor for a value range.  This
 /// implicitly uniques the values returned.
 public func LLVMDIBuilderGetOrCreateSubrange(_ Builder: LLVMDIBuilderRef!, _ Lo: Int64, _ Count: Int64) -> LLVMMetadataRef!

Sources/LLVM/DIType.swift

@@ -1,4 +1,4 @@
-#if !NO_SWIFTPM
+#if SWIFT_PACKAGE
 import cllvm
 #endif