Introduce a variant of RegisterBank for arrays

Sources/MMIO/MMIOMacros.swift

@@ -16,7 +16,11 @@ public macro RegisterBank() =
 
 @attached(accessor)
 public macro RegisterBank(offset: Int) =
-  #externalMacro(module: "MMIOMacros", type: "RegisterBankOffsetMacro")
+  #externalMacro(module: "MMIOMacros", type: "RegisterBankScalarMemberMacro")
+
+@attached(accessor)
+public macro RegisterBank(offset: Int, stride: Int, count: Int) =
+  #externalMacro(module: "MMIOMacros", type: "RegisterBankArrayMemberMacro")
 
 // Register macros
 @attached(member, names: arbitrary)

Sources/MMIO/RegisterArray.swift

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift MMIO open source project
+//
+// Copyright (c) 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+/// A container type referencing of a region of memory whose layout is defined
+/// by another type.
+public struct RegisterArray<Value> where Value: RegisterValue {
+  public var unsafeAddress: UInt
+  public var stride: UInt
+  public var count: UInt
+
+  #if FEATURE_INTERPOSABLE
+  public var interposer: (any MMIOInterposer)?
+  #endif
+
+  @inlinable @inline(__always)
+  static func preconditionAligned(unsafeAddress: UInt, stride: UInt) {
+    let alignment = MemoryLayout<Value.Raw.Storage>.alignment
+    #if $Embedded
+    // FIXME: Embedded doesn't have static interpolated strings yet
+    precondition(
+      unsafeAddress.isMultiple(of: UInt(alignment)),
+      "Misaligned address")
+    precondition(
+      stride.isMultiple(of: UInt(alignment)),
+      "Misaligned stride")
+    #else
+    precondition(
+      unsafeAddress.isMultiple(of: UInt(alignment)),
+      "Misaligned address '\(unsafeAddress)' for data of type '\(Value.self)'")
+    precondition(
+      stride.isMultiple(of: UInt(alignment)),
+      "Misaligned stride '\(unsafeAddress)' for data of type '\(Value.self)'")
+    #endif
+  }
+
+  #if FEATURE_INTERPOSABLE
+  @inlinable @inline(__always)
+  public init(
+    unsafeAddress: UInt,
+    stride: UInt,
+    count: UInt,
+    interposer: (any MMIOInterposer)?
+  ) {
+    Self.preconditionAligned(unsafeAddress: unsafeAddress, stride: stride)
+    self.unsafeAddress = unsafeAddress
+    self.stride = stride
+    self.count = count
+    self.interposer = interposer
+  }
+  #else
+  @inlinable @inline(__always)
+  public init(
+    unsafeAddress: UInt,
+    stride: UInt,
+    count: UInt
+  ) {
+    Self.preconditionAligned(unsafeAddress: unsafeAddress, stride: stride)
+    self.unsafeAddress = unsafeAddress
+    self.stride = stride
+    self.count = count
+  }
+  #endif
+}
+
+extension RegisterArray {
+  @inlinable @inline(__always)
+  subscript<Index>(
+    _ index: Index
+  ) -> Register<Value> where Index: BinaryInteger {
+    #if $Embedded
+    // FIXME: Embedded doesn't have static interpolated strings yet
+    precondition(
+      0 <= index && index < self.count,
+      "Index out of bounds")
+    #else
+    precondition(
+      0 <= index && index < self.count,
+      "Index '\(index)' out of bounds '0..<\(self.count)'")
+    #endif
+    let index = UInt(index)
+    #if FEATURE_INTERPOSABLE
+    return .init(
+      unsafeAddress: self.unsafeAddress + (index * self.stride),
+      interposer: self.interposer)
+    #else
+    return .init(unsafeAddress: self.unsafeAddress + (index * self.stride))
+    #endif
+  }
+}

Sources/MMIOMacros/CompilerPluginMain.swift

@@ -17,7 +17,8 @@ struct CompilerPluginMain: CompilerPlugin {
   let providingMacros: [Macro.Type] = [
     // RegisterBank macros
     RegisterBankMacro.self,
-    RegisterBankOffsetMacro.self,
+    RegisterBankScalarMemberMacro.self,
+    RegisterBankArrayMemberMacro.self,
     // Register macros
     RegisterMacro.self,
     ReservedMacro.self,

Sources/MMIOMacros/Macros/RegisterBankMacro.swift

@@ -59,7 +59,7 @@ extension RegisterBankMacro: MMIOMemberMacro {
       // RegisterBankOffsetMacro. Further syntactic checking will be performed
       // by that macro.
       do {
-        try variableDecl.requireMacro([RegisterBankOffsetMacro.self], context)
+        try variableDecl.requireMacro(registerBankMemberMacros, context)
       } catch _ {
         error = true
       }

Sources/MMIOMacros/Macros/RegisterBankMemberMacro.swift

@@ -0,0 +1,171 @@
+//===----------------------------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift MMIO open source project
+//
+// Copyright (c) 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacroExpansion
+import SwiftSyntaxMacros
+
+protocol RegisterBankMemberMacro: ParsableMacro {}
+
+extension RegisterBankMemberMacro {
+  func expansion(
+    of node: AttributeSyntax,
+    offset: ExprSyntax,
+    array: (stride: ExprSyntax, count: ExprSyntax)?,
+    providingAccessorsOf declaration: some DeclSyntaxProtocol,
+    in context: MacroContext<Self, some MacroExpansionContext>
+  ) throws -> [AccessorDeclSyntax] {
+    // Can only applied to variables.
+    let variableDecl =
+      try declaration.requireAs(VariableDeclSyntax.self, context)
+
+    // Must be `var` binding.
+    try variableDecl.requireBindingSpecifier(.var, context)
+
+    // Exactly one binding for the variable.
+    let binding = try variableDecl.requireSingleBinding(context)
+
+    // Binding identifier must be a simple identifier.
+    _ = try binding.requireSimpleBindingIdentifier(context)
+
+    // Binding must have a simple type annotation.
+    _ = try binding.requireSimpleTypeIdentifier(context)
+
+    // Binding must not have any accessors.
+    try binding.requireNoAccessor(context)
+
+    guard let array = array else {
+      return [
+        """
+        @inlinable @inline(__always) get {
+          #if FEATURE_INTERPOSABLE
+          return .init(unsafeAddress: self.unsafeAddress + (\(offset)), interposer: self.interposer)
+          #else
+          return .init(unsafeAddress: self.unsafeAddress + (\(offset)))
+          #endif
+        }
+        """
+      ]
+    }
+    return [
+      """
+      @inlinable @inline(__always) get {
+        #if FEATURE_INTERPOSABLE
+        return .init(unsafeAddress: self.unsafeAddress + (\(offset)), stride: \(array.stride), count: \(array.count), interposer: self.interposer)
+        #else
+        return .init(unsafeAddress: self.unsafeAddress + (\(offset)), stride: \(array.stride), count: \(array.count))
+        #endif
+      }
+      """
+    ]
+  }
+}
+
+let registerBankMemberMacros: [any RegisterBankMemberMacro.Type] = [
+  RegisterBankScalarMemberMacro.self,
+  RegisterBankArrayMemberMacro.self,
+]
+
+public struct RegisterBankScalarMemberMacro {
+  @Argument(label: "offset")
+  var offset: Int
+}
+
+extension RegisterBankScalarMemberMacro: Sendable {}
+
+extension RegisterBankScalarMemberMacro: ParsableMacro {
+  static let baseName = "RegisterBank"
+
+  mutating func update(
+    label: String,
+    from expression: ExprSyntax,
+    in context: MacroContext<some ParsableMacro, some MacroExpansionContext>
+  ) throws {
+    switch label {
+    case "offset":
+      try self._offset.update(from: expression, in: context)
+    default:
+      fatalError()
+    }
+  }
+}
+
+extension RegisterBankScalarMemberMacro: MMIOAccessorMacro {
+  static var accessorMacroSuppressParsingDiagnostics: Bool { false }
+
+  func expansion(
+    of node: AttributeSyntax,
+    providingAccessorsOf declaration: some DeclSyntaxProtocol,
+    in context: MacroContext<Self, some MacroExpansionContext>
+  ) throws -> [AccessorDeclSyntax] {
+    try self.expansion(
+      of: node,
+      offset: self.$offset,
+      array: nil,
+      providingAccessorsOf: declaration,
+      in: context)
+  }
+}
+
+extension RegisterBankScalarMemberMacro: RegisterBankMemberMacro {}
+
+public struct RegisterBankArrayMemberMacro {
+  @Argument(label: "offset")
+  var offset: Int
+  @Argument(label: "stride")
+  var stride: Int
+  @Argument(label: "count")
+  var count: Int
+}
+
+extension RegisterBankArrayMemberMacro: Sendable {}
+
+extension RegisterBankArrayMemberMacro: ParsableMacro {
+  static let baseName = "RegisterBank"
+
+  mutating func update(
+    label: String,
+    from expression: ExprSyntax,
+    in context: MacroContext<some ParsableMacro, some MacroExpansionContext>
+  ) throws {
+    switch label {
+    case "offset":
+      try self._offset.update(from: expression, in: context)
+    case "stride":
+      try self._stride.update(from: expression, in: context)
+    case "count":
+      try self._count.update(from: expression, in: context)
+    default:
+      fatalError()
+    }
+  }
+}
+
+extension RegisterBankArrayMemberMacro: MMIOAccessorMacro {
+  static var accessorMacroSuppressParsingDiagnostics: Bool { false }
+
+  func expansion(
+    of node: AttributeSyntax,
+    providingAccessorsOf declaration: some DeclSyntaxProtocol,
+    in context: MacroContext<Self, some MacroExpansionContext>
+  ) throws -> [AccessorDeclSyntax] {
+    try self.expansion(
+      of: node,
+      offset: self.$offset,
+      array: (stride: self.$stride, count: self.$count),
+      providingAccessorsOf: declaration,
+      in: context)
+  }
+}
+
+extension RegisterBankArrayMemberMacro: RegisterBankMemberMacro {}