Added LLVM Object File support

Author: harlanhaskins

Sources/LLVM/ObjectFile.swift

@@ -0,0 +1,150 @@
+#if !NO_SWIFTPM
+import cllvm
+#endif
+
+public enum ObjectFileError: Error {
+    case couldNotCreateFromBuffer(MemoryBuffer)
+}
+
+/// An in-memory representation of a platform object file.
+public class ObjectFile {
+    let llvm: LLVMObjectFileRef
+
+    public init?(memoryBuffer: MemoryBuffer) {
+        guard let file = LLVMCreateObjectFile(memoryBuffer.llvm) else {
+            return nil
+        }
+        self.llvm = file
+    }
+
+    public convenience init?(path: String) throws {
+        guard let memoryBuffer = try? MemoryBuffer(contentsOf: path) else {
+            return nil
+        }
+        self.init(memoryBuffer: memoryBuffer)
+    }
+
+    public var sections: SectionSequence {
+        return SectionSequence(llvm: LLVMGetSections(llvm), object: self)
+    }
+
+    public var symbols: SymbolSequence {
+        return SymbolSequence(llvm: LLVMGetSymbols(llvm), object: self)
+    }
+
+    deinit {
+        LLVMDisposeObjectFile(llvm)
+    }
+}
+
+public struct Section {
+    public let name: String
+    public let size: Int
+    public let contents: String
+    public let address: Int
+
+    internal init(fromIterator si: LLVMSectionIteratorRef) {
+        name = String(cString: LLVMGetSectionName(si))
+        size = Int(LLVMGetSectionSize(si))
+        contents = String(cString: LLVMGetSectionContents(si))
+        address = Int(LLVMGetSectionAddress(si))
+    }
+}
+
+public class SectionSequence: Sequence {
+    let llvm: LLVMSectionIteratorRef
+    let objectFile: ObjectFile
+
+    init(llvm: LLVMSectionIteratorRef, object: ObjectFile) {
+        self.llvm = llvm
+        self.objectFile = object
+    }
+
+    public func makeIterator() -> AnyIterator<Section> {
+        return AnyIterator {
+            if LLVMIsSectionIteratorAtEnd(self.objectFile.llvm, self.llvm) != 0 {
+                return nil
+            }
+            defer { LLVMMoveToNextSection(self.llvm) }
+            return Section(fromIterator: self.llvm)
+        }
+    }
+
+    deinit {
+        LLVMDisposeSectionIterator(llvm)
+    }
+}
+
+public struct Symbol {
+    public let name: String
+    public let size: Int
+    public let address: Int
+
+    internal init(fromIterator si: LLVMSymbolIteratorRef) {
+        self.name = String(cString: LLVMGetSymbolName(si))
+        self.size = Int(LLVMGetSymbolSize(si))
+        self.address = Int(LLVMGetSymbolAddress(si))
+    }
+}
+
+public struct Relocation {
+    public let type: Int
+    public let offset: Int
+    public let symbol: Symbol
+    public let typeName: String
+
+    internal init(fromIterator ri: LLVMRelocationIteratorRef) {
+        self.type = Int(LLVMGetRelocationType(ri))
+        self.offset = Int(LLVMGetRelocationOffset(ri))
+        self.symbol = Symbol(fromIterator: LLVMGetRelocationSymbol(ri))
+        self.typeName = String(cString: LLVMGetRelocationTypeName(ri))
+    }
+}
+
+public class RelocationSequence: Sequence {
+    let llvm: LLVMRelocationIteratorRef
+    let sectionIterator: LLVMSectionIteratorRef
+
+    init(llvm: LLVMRelocationIteratorRef, sectionIterator: LLVMSectionIteratorRef) {
+        self.llvm = llvm
+        self.sectionIterator = sectionIterator
+    }
+
+    public func makeIterator() -> AnyIterator<Relocation> {
+        return AnyIterator {
+            if LLVMIsRelocationIteratorAtEnd(self.sectionIterator, self.llvm) != 0 {
+                return nil
+            }
+            defer { LLVMMoveToNextRelocation(self.llvm) }
+            return Relocation(fromIterator: self.llvm)
+        }
+    }
+
+    deinit {
+        LLVMDisposeSectionIterator(llvm)
+    }
+}
+
+public class SymbolSequence: Sequence {
+    let llvm: LLVMSymbolIteratorRef
+    let object: ObjectFile
+
+    init(llvm: LLVMRelocationIteratorRef, object: ObjectFile) {
+        self.llvm = llvm
+        self.object = object
+    }
+
+    public func makeIterator() -> AnyIterator<Symbol> {
+        return AnyIterator {
+            if LLVMIsSymbolIteratorAtEnd(self.object.llvm, self.llvm) != 0 {
+                return nil
+            }
+            defer { LLVMMoveToNextSymbol(self.llvm) }
+            return Symbol(fromIterator: self.llvm)
+        }
+    }
+
+    deinit {
+        LLVMDisposeSymbolIterator(llvm)
+    }
+}