Interpreter: Make function calls and basic instructions working

Sources/Interpreter/Memory.swift

@@ -125,14 +125,14 @@ public struct Memory {
     }
 
     mutating func withUnsafeMutablePointer<T, R>(to _: T.Type, at a: Offset, _ body: (UnsafeMutablePointer<T>)->R) -> R {
-      precondition(a + MemoryLayout<T>.size < size)
+      precondition(a + MemoryLayout<T>.size <= size)
       return storage.withUnsafeMutableBytes { p in
         body((p.baseAddress! + baseOffset + a).assumingMemoryBound(to: T.self))
       }
     }
 
     func withUnsafePointer<T, R>(to _: T.Type, at a: Offset, _ body: (UnsafePointer<T>)->R) -> R {
-      precondition(a + MemoryLayout<T>.size < size)
+      precondition(a + MemoryLayout<T>.size <= size)
       return storage.withUnsafeBytes { p in
         body((p.baseAddress! + baseOffset + a).assumingMemoryBound(to: T.self))
       }
@@ -171,7 +171,7 @@ public struct Memory {
       }
     }
 
-    /// Returns true if `o` is alinged to an `n` byte boundary.
+    /// Returns true if `o` is aligned to an `n` byte boundary.
     public func offset(_ o: Offset, hasAlignment n: Int) -> Bool {
       storage.withUnsafeBytes {
         UInt(bitPattern: $0.baseAddress! + baseOffset + o) % UInt(n) == 0
@@ -257,7 +257,7 @@ public struct Memory {
     try allocation[a.allocation]!.compose(t, at: a.offset)
   }
 
-  /// Returns true if `a` is alinged to an `n` byte boundary.
+  /// Returns true if `a` is aligned to an `n` byte boundary.
   public func address(_ a: Address, hasAlignment n: Int) -> Bool {
     allocation[a.allocation]!.offset(a.offset, hasAlignment: n)
   }
@@ -278,6 +278,33 @@ public struct Memory {
     throw Error.noDecomposable(t, at: a)
   }
 
+  /// Copies `n` bytes from `source` to `destination`.
+  public mutating func copy(
+    bytes n: Int, from source: Memory.Address, to destination: Memory.Address
+  ) {
+    precondition(source.offset + n <= self[source.allocation].size)
+    precondition(destination.offset + n <= self[destination.allocation].size)
+    let sourceBaseOffset = self[source.allocation].baseOffset
+    let destinationBaseOffset = self[destination.allocation].baseOffset
+    self[source.allocation].storage.withUnsafeBytes { sourceBuffer in
+      self[destination.allocation].storage.withUnsafeMutableBytes { destBuffer in
+        let s = sourceBuffer.baseAddress! + sourceBaseOffset + source.offset
+        let d = destBuffer.baseAddress! + destinationBaseOffset + destination.offset
+        d.copyMemory(from: s, byteCount: n)
+      }
+    }
+  }
+
+  /// The allocation identified by `i`.
+  public subscript(_ i: Allocation.ID) -> Allocation {
+    _read {
+      yield allocation[i]!
+    }
+    _modify {
+      yield &allocation[i]!
+    }
+  }
+
 }
 
 public extension Memory.Address {
@@ -299,3 +326,22 @@ public extension Memory.Address {
   static func -=(l: inout Self, r: Int)  { l = l - r }
 
 }
+
+extension Memory.Allocation {
+
+  /// Yields value of type `t` stored at offset `a` in allocation.
+  subscript<T>(_ a: Memory.Offset, type t: T.Type) -> T
+  {
+    get {
+      withUnsafePointer(to: t, at: a) {
+        $0.pointee
+      }
+    }
+    set {
+      withUnsafeMutablePointer(to: t, at: a) {
+        $0.pointee = newValue
+      }
+    }
+  }
+
+}

Sources/Interpreter/TargetABI.swift

@@ -20,9 +20,10 @@ public struct UnrealABI: TargetABI {
     precondition(
       bitWidth > 0 && bitWidth.nonzeroBitCount == 1,
       "bit width \(bitWidth) is not a power of 2.")
+    let sizeInBytes = (bitWidth + 7) / 8
     return .init(
-      alignment: min(bitWidth / 8, maxAlignment),
-      size: bitWidth / 8)
+      alignment: min(sizeInBytes, maxAlignment),
+      size: sizeInBytes)
   }
 
   public func layout(_ t: BuiltinType) -> TypeLayout.Bytes {

Sources/Interpreter/UntypedBuiltinValue.swift

@@ -0,0 +1,78 @@
+import IR
+
+/// The value of a `Builtin` type instance, stripped of type information.
+struct UntypedBuiltinValue {
+
+  /// The result of reinterpretation as an unsigned integer value.
+  ///
+  /// Equivalent to `UInt128(unsafeBitCast<T>(x))`, where `x` is the represented value
+  /// and `T` is an unsigned integer of the same size as `x`.  Stores the unsigned
+  /// representation of integer types.
+  private let asUInt128: UInt128
+
+  /// The size of the value in bytes.
+  private let size: Int
+
+  /// Creates instance of builtin value with unsigned reinterpretation `v` and size `s`.
+  fileprivate init(asUInt128 v: UInt128, size s: Int) {
+    asUInt128 = v
+    size = s
+  }
+
+  /// Creates instance of builtin value with 8-bit integer.
+  static func i8(_ v: UInt8) -> Self {
+    Self(asUInt128: UInt128(v), size: 1)
+  }
+
+  /// Creates instance of builtin value with 16-bit integer.
+  public static func i16(_ v: UInt16) -> Self {
+    Self(asUInt128: UInt128(v), size: 2)
+  }
+
+  /// Creates instance of builtin value with 32-bit integer.
+  public static func i32(_ v: UInt32) -> Self {
+    Self(asUInt128: UInt128(v), size: 4)
+  }
+
+  /// Creates instance of builtin value with 64-bit integer.
+  public static func i64(_ v: UInt64) -> Self {
+    Self(asUInt128: UInt128(v), size: 8)
+  }
+
+  /// Creates instance of builtin value with 128-bit integer.
+  public static func i128(_ v: UInt128) -> Self {
+    Self(asUInt128: UInt128(v), size: 16)
+  }
+
+  /// Bool value, if present.
+  public var bool: Bool? {
+    if asUInt128 != 0 && asUInt128 != 1 { return nil }
+    return asUInt128 != 0
+  }
+
+  /// 8-bit integer value, if present.
+  public var i8: UInt8? { size == 1 ? UInt8(truncatingIfNeeded: asUInt128) : nil }
+
+  /// 16-bit integer value, if present
+  public var i16: UInt16? { size == 2 ? UInt16(truncatingIfNeeded: asUInt128) : nil }
+
+  /// 32-bit integer value, if present
+  public var i32: UInt32? { size == 4 ? UInt32(truncatingIfNeeded: asUInt128) : nil }
+
+  /// 64-bit integer value, if present
+  public var i64: UInt64? { size == 8 ? UInt64(truncatingIfNeeded: asUInt128) : nil }
+
+  /// 128-bit integer value, if present
+  public var i128: UInt128? { size == 16 ? asUInt128 : nil }
+
+}
+
+/// Methods to create builtin value from IR constants.
+extension UntypedBuiltinValue {
+
+  /// Creates instance of builtin value with integer constant `c`.
+  public init(withIntegerConstant c: IntegerConstant) {
+    self.init(asUInt128: UInt128(truncatingIfNeeded: c.value), size: (c.value.bitWidth + 7) / 8)
+  }
+
+}

Tests/CMakeLists.txt

@@ -31,7 +31,7 @@ add_hylo_test_of(FrontEnd NAMED HyloTests
   DEPENDENCIES IR TestUtils StandardLibrary Utils Algorithms)
 
 add_hylo_test_of(Interpreter NAMED InterpreterTests
-  DEPENDENCIES Interpreter IR
+  DEPENDENCIES Interpreter FrontEnd IR TestUtils
   # TODO: why is this needed?
   Collections
 )

Tests/InterpreterTests/InterpreterTests.swift

@@ -1,4 +1,3 @@
-import Driver
 import Foundation
 import IR
 import XCTest
@@ -21,4 +20,68 @@ final class InterpreterRunTests: XCTestCase {
     }
   }
 
+  func testStackAllocAndDealloc() throws {
+    let input =
+      """
+        public fun main() {
+          let x = 2
+          let y = 2
+        }
+      """.asSourceFile()
+    let module = try input.loweredToIRAsMainWithHostedStandardLibrary();
+    let program = IR.Program.init(syntax: module.program, modules: [module.id: module]);
+    var executor = Interpreter(program);
+    while executor.isRunning {
+      try executor.step()
+    }
+  }
+
+  func testFunctionCall() throws {
+    let input =
+      """
+       public fun dummy() {}
+
+       public fun id(_ x: sink Int) -> Int {
+         dummy()
+         return x
+       }
+
+       public fun main() {
+         let x = 2
+         let y = id(x)
+         let z = 3
+       }
+      """.asSourceFile()
+    let module = try input.loweredToIRAsMainWithHostedStandardLibrary();
+    let program = IR.Program.init(syntax: module.program, modules: [module.id: module]);
+    var executor = Interpreter(program);
+    while executor.isRunning {
+      try executor.step()
+    }
+  }
+
+  func testBranch() throws {
+    let input =
+      """
+       public fun select(_ cond: Bool, _ first: sink Int, _ second: sink Int) -> Int {
+         if cond {
+           return first
+         }else{
+           return second
+         }
+       }
+
+       public fun main() {
+         _ = select(true, 2, 3)
+         _ = select(false, 2, 3)
+       }
+      """.asSourceFile()
+    let module = try input.loweredToIRAsMainWithHostedStandardLibrary();
+    let program = IR.Program.init(syntax: module.program, modules: [module.id: module]);
+    var executor = Interpreter(program);
+    while executor.isRunning {
+      try executor.step()
+    }
+  }
+
 }

Tests/InterpreterTests/MemoryTests+internal.swift

@@ -1,6 +1,7 @@
 import XCTest
 import TestUtils
 import FrontEnd
+import XCTest
 @testable import Interpreter
 
 final class InterpreterMemoryInternalTests: XCTestCase {

Tests/InterpreterTests/MemoryTests.swift

@@ -2,6 +2,7 @@ import FrontEnd
 import XCTest
 import TestUtils
 import Interpreter
+import XCTest
 
 final class InterpreterMemoryTests: XCTestCase {
 
@@ -149,4 +150,5 @@ final class InterpreterMemoryTests: XCTestCase {
       try m.decompose(i16, at: p + parts[1].offset)
      */
   }
+
 }