stdlib: add support for AAPCS64 variadics

Author: KoVuInc

lib/ClangImporter/ImportDecl.cpp

@@ -311,8 +311,12 @@ getSwiftStdlibType(const clang::TypedefNameDecl *D,
     break;
 
   case MappedCTypeKind::VaList:
-    if (ClangTypeSize != ClangCtx.getTypeSize(ClangCtx.VoidPtrTy))
-      return std::make_pair(Type(), "");
+
+    if (ClangTypeSize != ClangCtx.getTypeSize(ClangCtx.VoidPtrTy)){
+       if(ClangCtx.getTargetInfo().getBuiltinVaListKind() != clang::TargetInfo::AArch64ABIBuiltinVaList)
+         return std::make_pair(Type(), "");
+    }
+
     break;
 
   case MappedCTypeKind::ObjCBool:

stdlib/public/core/CTypes.swift

@@ -227,6 +227,29 @@ extension UInt {
   }
 }
 
+#if arch(arm64) && !(os(macOS) || os(iOS) || os(tvOS) || os(watchOS))
+
+@_fixed_layout
+public struct CVaListPointer {
+  @_versioned // FIXME(sil-serialize-all)
+  internal var value: (__stack: UnsafeMutablePointer<Int>?,
+                       __gr_top: UnsafeMutablePointer<Int>?,
+                       __vr_top: UnsafeMutablePointer<Int>?,
+                       __gr_off: Int32,
+                       __vr_off: Int32)
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public // @testable
+  init(__stack: UnsafeMutablePointer<Int>?,
+       __gr_top: UnsafeMutablePointer<Int>?,
+       __vr_top: UnsafeMutablePointer<Int>?,
+       __gr_off: Int32,
+       __vr_off: Int32) {
+    value = (__stack, __gr_top, __vr_top, __gr_off, __vr_off)
+  }
+}
+
+#else
 /// A wrapper around a C `va_list` pointer.
 @_fixed_layout
 public struct CVaListPointer {
@@ -248,6 +271,8 @@ extension CVaListPointer : CustomDebugStringConvertible {
   }
 }
 
+#endif
+
 @_versioned
 @_inlineable
 internal func _memcpy(

stdlib/public/core/VarArgs.swift

@@ -85,6 +85,30 @@ internal let _registerSaveWords = _countGPRegisters + _countSSERegisters * _sseR
 internal let _countGPRegisters = 16
 @_versioned
 internal let _registerSaveWords = _countGPRegisters
+
+#elseif arch(arm64)
+
+// ARM IHI 0055B
+// va_list may refer to any paramenter may be in one of three memory locations:
+// 1. GP register save area x0 - x7
+// 2. FP/SIMD register save area q0 - q7
+// 3. Stack argument area
+//
+
+@_versioned
+internal let _countGPRegisters = 8
+
+@_versioned
+internal let _countFPRegisters = 8
+
+//128bit, 2 64bit word
+@_versioned
+internal let _fpRegisterWords = 2
+
+@_versioned
+internal let _registerSaveWords = _countGPRegisters + (_countFPRegisters * _fpRegisterWords)
+
+
 #endif
 
 #if arch(s390x)
@@ -467,6 +491,140 @@ final internal class _VaListBuilder {
   internal var storage: ContiguousArray<Int>
 }
 
+#elseif arch(arm64) && !(os(macOS) || os(iOS) || os(tvOS) || os(watchOS))
+
+
+@_fixed_layout // FIXME(sil-serialize-all)
+@_versioned // FIXME(sil-serialize-all)
+final internal class _VaListBuilder {
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal init() {
+    // prepare the register save area
+    allocated = _registerSaveWords
+    storage = allocStorage(wordCount: allocated)
+    // append stack arguments after register save area
+    count = allocated
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  deinit {
+    if let allocatedStorage = storage {
+      deallocStorage(wordCount: allocated, storage: allocatedStorage)
+    }
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal func append(_ arg: CVarArg) {
+    var encoded = arg._cVarArgEncoding
+
+    if arg is _CVarArgPassedAsDouble
+      && fpRegistersUsed < _countFPRegisters {
+        var startIndex = (fpRegistersUsed * _fpRegisterWords)
+          for w in encoded {
+            storage[startIndex] = w
+            startIndex += 1
+          }
+          fpRegistersUsed += 1
+    }else if encoded.count == 1
+        && !(arg is _CVarArgPassedAsDouble)
+        && gpRegistersUsed < _countGPRegisters {
+        var startIndex = ( _fpRegisterWords * _countFPRegisters) + gpRegistersUsed
+        storage[startIndex] = encoded[0]
+        gpRegistersUsed += 1
+    }else{
+        //arguments in stack slot
+        appendWords(encoded)
+    }
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal func va_list() -> CVaListPointer {
+    let vr_top = storage + (_fpRegisterWords * _countFPRegisters)
+    let gr_top = vr_top + _countGPRegisters
+
+    return CVaListPointer(__stack: gr_top, __gr_top: gr_top,
+                          __vr_top: vr_top, __gr_off: -64, __vr_off: -128)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal func appendWords(_ words: [Int]) {
+    let newCount = count + words.count
+    if newCount > allocated {
+      let oldAllocated = allocated
+      let oldStorage = storage
+      let oldCount = count
+
+      allocated = max(newCount, allocated * 2)
+      let newStorage = allocStorage(wordCount: allocated)
+      storage = newStorage
+      // count is updated below
+
+      if let allocatedOldStorage = oldStorage {
+        newStorage.moveInitialize(from: allocatedOldStorage, count: oldCount)
+        deallocStorage(wordCount: oldAllocated, storage: allocatedOldStorage)
+      }
+    }
+
+    let allocatedStorage = storage!
+    for word in words {
+      allocatedStorage[count] = word
+      count += 1
+    }
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal func rawSizeAndAlignment(
+    _ wordCount: Int
+  ) -> (Builtin.Word, Builtin.Word) {
+    return ((wordCount * MemoryLayout<Int>.stride)._builtinWordValue,
+      requiredAlignmentInBytes._builtinWordValue)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal func allocStorage(wordCount: Int) -> UnsafeMutablePointer<Int> {
+    let (rawSize, rawAlignment) = rawSizeAndAlignment(wordCount)
+    let rawStorage = Builtin.allocRaw(rawSize, rawAlignment)
+    return UnsafeMutablePointer<Int>(rawStorage)
+  }
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal func deallocStorage(
+    wordCount: Int, storage: UnsafeMutablePointer<Int>
+  ) {
+    let (rawSize, rawAlignment) = rawSizeAndAlignment(wordCount)
+    Builtin.deallocRaw(storage._rawValue, rawSize, rawAlignment)
+  }
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal let requiredAlignmentInBytes = MemoryLayout<Double>.alignment
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var count = 0
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var allocated = 0
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var storage: UnsafeMutablePointer<Int>!
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var gpRegistersUsed = 0
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var fpRegistersUsed = 0
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var overflowWordsUsed = 0
+}
+
 #else
 
 /// An object that can manage the lifetime of storage backing a