SwiftDriver: migrate LLVM bitcode support from tools-support-core

The swift-driver is the only consumer of the bitcode implementation in
TSCUtility.  Migrate the code to the single user to allow us to
deprecate the API in tools-support-core.  While there are no practical
changes to the implementation, this does take the opportunity to split
up the bitcode implementation into multiple files.

Author: compnerd

Sources/SwiftDriver/CMakeLists.txt

@@ -34,6 +34,15 @@ add_library(SwiftDriver
   Execution/ParsableOutput.swift
   Execution/ProcessProtocol.swift
 
+  "IncrementalCompilation/Bitcode/Bitcode.swift"
+  "IncrementalCompilation/Bitcode/BitcodeElement.swift"
+  "IncrementalCompilation/Bitcode/Bits.swift"
+  "IncrementalCompilation/Bitcode/Bitstream.swift"
+  "IncrementalCompilation/Bitcode/BitstreamReader.swift"
+  "IncrementalCompilation/Bitcode/BitstreamVisitor.swift"
+  "IncrementalCompilation/Bitcode/BitstreamWriter.swift"
+  "IncrementalCompilation/Bitcode/BlockInfo.swift"
+
   "IncrementalCompilation/BuildRecord.swift"
   "IncrementalCompilation/BuildRecordInfo.swift"
   "IncrementalCompilation/DependencyGraphDotFileWriter.swift"

Sources/SwiftDriver/IncrementalCompilation/Bitcode/Bitcode.swift

@@ -0,0 +1,53 @@
+//===--------------- BitCode.swift - LLVM BitCode Helpers ----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct TSCBasic.ByteString
+
+public struct Bitcode {
+  public let signature: Bitcode.Signature
+  public let elements: [BitcodeElement]
+  public let blockInfo: [UInt64:BlockInfo]
+}
+
+extension Bitcode {
+  public struct Signature: Equatable {
+    private var value: UInt32
+
+    public init(value: UInt32) {
+      self.value = value
+    }
+
+    public init(string: String) {
+      precondition(string.utf8.count == 4)
+      var result: UInt32 = 0
+      for byte in string.utf8.reversed() {
+        result <<= 8
+        result |= UInt32(byte)
+      }
+      self.value = result
+    }
+  }
+}
+
+extension Bitcode {
+  /// Traverse a bitstream using the specified `visitor`, which will receive
+  /// callbacks when blocks and records are encountered.
+  public static func read<Visitor: BitstreamVisitor>(bytes: ByteString, using visitor: inout Visitor) throws {
+    precondition(bytes.count > 4)
+    var reader = BitstreamReader(buffer: bytes)
+    try visitor.validate(signature: reader.readSignature())
+    try reader.readBlock(id: BitstreamReader.fakeTopLevelBlockID,
+                         abbrevWidth: 2,
+                         abbrevInfo: [],
+                         visitor: &visitor)
+  }
+}

Sources/SwiftDriver/IncrementalCompilation/Bitcode/BitcodeElement.swift

@@ -0,0 +1,54 @@
+//===--------------- BitcodeElement.swift - LLVM Bitcode Elements --------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+public enum BitcodeElement {
+  public struct Block {
+    public var id: UInt64
+    public var elements: [BitcodeElement]
+  }
+
+  /// A record element.
+  ///
+  /// - Warning: A `Record` element's fields and payload only live as long as
+  ///            the `visit` function that provides them is called. To persist
+  ///            a record, always make a copy of it.
+  public struct Record {
+    public enum Payload {
+      case none
+      case array([UInt64])
+      case char6String(String)
+      case blob(ArraySlice<UInt8>)
+    }
+
+    public var id: UInt64
+    public var fields: UnsafeBufferPointer<UInt64>
+    public var payload: Payload
+  }
+
+  case block(Block)
+  case record(Record)
+}
+
+extension BitcodeElement.Record.Payload: CustomStringConvertible {
+  public var description: String {
+    switch self {
+    case .none:
+      return "none"
+    case .array(let vals):
+      return "array(\(vals))"
+    case .char6String(let s):
+      return "char6String(\(s))"
+    case .blob(let s):
+      return "blob(\(s.count) bytes)"
+    }
+  }
+}

Sources/SwiftDriver/IncrementalCompilation/Bitcode/Bits.swift

@@ -0,0 +1,113 @@
+//===--------------- Bits.swift - Bitstream helpers ----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct TSCBasic.ByteString
+
+struct Bits: RandomAccessCollection {
+  var buffer: ByteString
+
+  var startIndex: Int { return 0 }
+  var endIndex: Int { return buffer.count * 8 }
+
+  subscript(index: Int) -> UInt8 {
+    let byte = buffer.contents[index / 8]
+    return (byte >> UInt8(index % 8)) & 1
+  }
+
+  func readBits(atOffset offset: Int, count: Int) -> UInt64 {
+    precondition(count >= 0 && count <= 64)
+    precondition(offset >= 0)
+    precondition(offset &+ count >= offset)
+    precondition(offset &+ count <= self.endIndex)
+
+    return buffer.contents.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) in
+      let upperBound = offset &+ count
+      let topByteIndex = upperBound >> 3
+      var result: UInt64 = 0
+      if upperBound & 7 != 0 {
+        let mask: UInt8 = (1 << UInt8(upperBound & 7)) &- 1
+        result = UInt64(bytes[topByteIndex] & mask)
+      }
+      for i in ((offset >> 3)..<(upperBound >> 3)).reversed() {
+        result <<= 8
+        result |= UInt64(bytes[i])
+      }
+      if offset & 7 != 0 {
+        result >>= UInt64(offset & 7)
+      }
+      return result
+    }
+  }
+}
+
+extension Bits {
+  struct Cursor {
+    enum Error: Swift.Error { case bufferOverflow }
+
+    let buffer: Bits
+    private var offset: Int = 0
+
+    init(buffer: Bits) {
+      self.buffer = buffer
+    }
+    
+    init(buffer: ByteString) {
+      self.init(buffer: Bits(buffer: buffer))
+    }
+
+    var isAtStart: Bool {
+      return offset == buffer.startIndex
+    }
+
+    var isAtEnd: Bool {
+      return offset == buffer.count
+    }
+
+    func peek(_ count: Int) throws -> UInt64 {
+      if buffer.count - offset < count { throw Error.bufferOverflow }
+      return buffer.readBits(atOffset: offset, count: count)
+    }
+
+    mutating func read(_ count: Int) throws -> UInt64 {
+      defer { offset += count }
+      return try peek(count)
+    }
+
+    mutating func read(bytes count: Int) throws -> ArraySlice<UInt8> {
+      precondition(count >= 0)
+      precondition(offset & 0b111 == 0)
+      let newOffset = offset &+ (count << 3)
+      precondition(newOffset >= offset)
+      if newOffset > buffer.count { throw Error.bufferOverflow }
+      defer { offset = newOffset }
+      return buffer.buffer.contents.dropFirst(offset >> 3).prefix((newOffset - offset) >> 3)
+    }
+
+    mutating func skip(bytes count: Int) throws {
+      precondition(count >= 0)
+      precondition(offset & 0b111 == 0)
+      let newOffset = offset &+ (count << 3)
+      precondition(newOffset >= offset)
+      if newOffset > buffer.count { throw Error.bufferOverflow }
+      offset = newOffset
+    }
+
+    mutating func advance(toBitAlignment align: Int) throws {
+      precondition(align > 0)
+      precondition(offset &+ (align&-1) >= offset)
+      precondition(align & (align &- 1) == 0)
+      if offset % align == 0 { return }
+      offset = (offset &+ align) & ~(align &- 1)
+      if offset > buffer.count { throw Error.bufferOverflow }
+    }
+  }
+}