polymorphic_builtins.swift

import Builtin

// =============================================================================

// A `Never`-like type for default implementations and associated types
@frozen
publicenum_SIMDNever{}

// A `Never`-like type for default implementations that provides a SIMDScalar
// based T for use in where requirements.
//
// This is necessary for the following code to properly compile:
//
// extension _SIMDGenericNever: _SIMDStorageWithOps {
// public typealias Scalar = T
// public typealias _InnerStorage = _SIMDGenericNever<T>
// ...
// }
//
// Given that we want _InnerStorage.Scalar to equal specific Scalar values to
// appease the type checker. If one does not need this functionality, just pass
// _SIMDNever as the generic parameter since it is a SIMDScalar.
@frozen
publicenum_SIMDGenericNever<T :SIMDScalar>{}

// =============================================================================

publicprotocolSIMDStorage{
associatedtypeScalar:SIMDScalar
associatedtype_InnerStorage:_SIMDStorageWithOps=_SIMDGenericNever<_SIMDNever> where _InnerStorage.Scalar== Self.Scalar

staticvar_hasVectorRepresentation:Bool{get}

staticvarscalarCount:Int{get}

var_innerStorage:_InnerStorage{getset}

varscalarCount:Int{get}

init()

init(_storage:_InnerStorage)

 subscript(index:Int)->Scalar{getset}
}

extensionSIMDStorage{
@_transparent
publicstaticvar_hasVectorRepresentation:Bool{
returnfalse
}

publicvar_innerStorage:_InnerStorage{
@inline(never)
get{
 // Will never be called unless `_hasVectorRepresentation == true`,
 // in which case this implementation would be overridden in stdlib
fatalError("""
 Error! Called default SIMDStorage._vector impl?! A SIMDStorage class
 overrides _hasVectorRepresentation to return true, but did not provide
 an implementation for this method as well!
""")
}
set{
fatalError("""
 Error! Called default SIMDStorage._vector impl?! A SIMDStorage class
 overrides _hasVectorRepresentation to return true, but did not provide
 an implementation for this method as well!
""")
}
}

 // Previously, the static `scalarCount` was defined in terms of this
 // property; also I think this property should be deprecated altogether
publicvarscalarCount:Int{
@_transparent
get{
returnSelf.scalarCount
}
}

@inline(never)
publicinit(_storage:_InnerStorage){
 // Will never be called unless `_hasVectorRepresentation == true`, in
 // which case this implementation would be overridden in stdlib
fatalError("""
 Error! Called default SIMDStorage.init(_vector) impl?! A SIMDStorage class
 overrides _hasVectorRepresentation to return true, but did not provide an
 implementation for this method as well!
""")
}
}

publicprotocol_SIMDStorageWithOps:SIMDStorage{
staticfunc add(_ lhs:Self, _ rhs:Self)->Self
staticfunc mul(_ lhs:Self, _ rhs:Self)->Self
}

extension_SIMDStorageWithOps{
publicstaticfunc add(_ lhs:Self, _ rhs:Self)->Self{
fatalError("In default SIMDStorageWithOps impl. Only here for never types?!")
}

publicstaticfunc mul(_ lhs:Self, _ rhs:Self)->Self{
fatalError("In default SIMDStorageWithOps impl. Only here for never types?!")
}

}

extension_SIMDNever:_SIMDStorageWithOps{
publictypealiasScalar=_SIMDNever
publictypealias_InnerStorage=_SIMDNever

publicstaticfunc add(_ lhs:Self, _ rhs:Self)->Self{}
publicstaticfunc mul(_ lhs:Self, _ rhs:Self)->Self{}

publicstaticvarscalarCount:Int{
@inline(never)
get{
switchSelf(){}
}
}

publicvar_innerStorage:_InnerStorage{
get{
switchSelf(){}
}
set{
}
}

public subscript(index:Int)->Scalar{
@inline(never)
get{
switchself{}
}
set{}
}

@inline(never)
publicinit(){
fatalError("\(Self.self) cannot be instantiated")
}
}

extension_SIMDGenericNever:_SIMDStorageWithOps{
publictypealiasScalar=T
publictypealias_InnerStorage=_SIMDGenericNever<T>

publicstaticfunc add(_ lhs:Self, _ rhs:Self)->Self{}

publicstaticvarscalarCount:Int{
@inline(never)
get{
switchSelf(){}
}
}

public subscript(index:Int)->Scalar{
@inline(never)
get{
switchself{}
}
set{}
}

@inline(never)
publicinit(){
fatalError("\(Self.self) cannot be instantiated")
}

publicvar_innerStorage:_InnerStorage{
get{
switchSelf(){}
}
set{
}
}
}

// =============================================================================

publicprotocolSIMDScalar{
 // ...

associatedtypeSIMD4Storage:_SIMDStorageWithOpswhere SIMD4Storage.Scalar ==Self

 // ...
}

extension_SIMDNever:SIMDScalar{
 // ...

publictypealiasSIMD4Storage=_SIMDNever

 // ...
}

// =============================================================================

publicprotocolSIMD:SIMDStorage{
}

extensionSIMD{
publicvarindices:Range<Int>{
@_transparentget{
return0..< scalarCount
}
}

 // ...

@_transparent
publicinit(_storage:_InnerStorage){
self.init()
 _innerStorage = _storage
}
}

extensionSIMDwhere Scalar:FixedWidthInteger{
@_transparent
publicstaticfunc&+(lhs:Self, rhs:Self)->Self{
 // In this case, we guard using _isConcrete to ensure that if we call this
 // through a vtable, we go down the slow fallback path instead of hitting
 // the assert inserted by IRgen when it lowers the unspecialized polymorphic
 // builtin.
if_fastPath(Self._hasVectorRepresentation && _isConcrete(Self.self)){
 // Delegate to concrete operations on `Self._InnerStorage`
letlVec= lhs._innerStorage
letrVec= rhs._innerStorage
letresult=Self._InnerStorage.add(lVec, rVec)
returnSelf(_storage: result)
}

 // Slow fallback
varresult=Self()
foriin result.indices {result[i]=lhs[i]&+rhs[i]}
return result
}

@_transparent
publicstaticfunc&*(lhs:Self, rhs:Self)->Self{
 // We'll almost always be calling this on stdlib SIMD types, so this
 // branch is very likely in a generic context.
 //
 // This is purposely unguarded so in our test cases we can validate that
 // without the guard an implementation like this asserts.
if_fastPath(Self._hasVectorRepresentation){
 // Delegate to concrete operations on `Self._Vector`
letlVec= lhs._innerStorage
letrVec= rhs._innerStorage
letresult=Self._InnerStorage.mul(lVec, rVec)
returnSelf(_storage: result)
}

 // Slow fallback
varresult=Self()
foriin result.indices {result[i]=lhs[i]&*rhs[i]}
return result
}
}

// =============================================================================

@frozen
publicstructSIMD4<Scalar:SIMDScalar>:SIMD{
publictypealias_InnerStorage=Scalar.SIMD4Storage

publicvar_innerStorage:_InnerStorage{
@_transparent
get{return _storage }
@_transparent
set{ _storage = newValue }
}

publicstaticvar_hasVectorRepresentation:Bool{
@_transparentget{
returnScalar.SIMD4Storage._hasVectorRepresentation
}
}

publicstaticvarscalarCount:Int{
@_transparentget{
returnScalar.SIMD4Storage.scalarCount
}
}

publicvar_storage:Scalar.SIMD4Storage

public subscript(index:Int)->Scalar{
@_transparentget{
returnself._storage[index]
}
@_transparentset{
self._storage[index]= newValue
}
}

@_transparent
publicinit(){
 _storage =Scalar.SIMD4Storage()
}

publicinit(_ inputValues:[Scalar]){
self.init()
assert(inputValues.count ==Self.scalarCount)
foriin0..<inputValues.count {
self[i]=inputValues[i]
}
}
 // ...

publicvarasArray:[Scalar]{
return(0..<Self.scalarCount).map{self[$0]}
}
}

publicprotocol_SIMDVectorStorage:_SIMDStorageWithOps{
 // Must be a builtin type eventually.
associatedtype_Vector

var_vector:_Vector{get}

init(_vector:_Vector)

staticfunc add(_ lhs:Self, _ rhs:Self)->Self

}

extension_SIMDVectorStorage{
@_transparent
publicstaticfunc add(_ lhs:Self, _ rhs:Self)->Self{
returnSelf(_vector:Builtin.generic_add(lhs._vector, rhs._vector))
}

@_transparent
publicstaticfunc mul(_ lhs:Self, _ rhs:Self)->Self{
returnSelf(_vector:Builtin.generic_mul(lhs._vector, rhs._vector))
}}

// =============================================================================

extensionInt32:SIMDScalar{
@frozen
publicstructSIMD4Storage:_SIMDVectorStorage{
publictypealiasScalar=Int32
 /// This specific struct does not have any inner storage.
publictypealias_InnerStorage=_SIMDGenericNever<Scalar>
publictypealias_Vector=Builtin.Vec4xInt32

publicstaticvar_hasVectorRepresentation:Bool{
@_transparentget{
returntrue
}
}

publicstaticvarscalarCount:Int{
@_transparentget{
return4
}
}

publicvar_vector:_Vector

public subscript(index:Int)->Scalar{
@_transparentget{
returnInt32(Builtin.extractelement_Vec4xInt32_Int32(
 _vector,
Int32(truncatingIfNeeded: index)._value
))
}
@_transparentset{
 _vector =Builtin.insertelement_Vec4xInt32_Int32_Int32(
 _vector,
 newValue._value,
Int32(truncatingIfNeeded: index)._value
)
}
}

@_transparent
publicinit(){
 _vector =Builtin.zeroInitializer()
}

@_transparent
publicinit(_vector:_Vector){
self._vector = _vector
}
}
}

extensionInt64:SIMDScalar{
@frozen
publicstructSIMD4Storage:_SIMDStorageWithOps{
publictypealiasScalar=Int64
publictypealias_InnerStorage=_SIMDGenericNever<Scalar>
publictypealias_Vector=Builtin.Vec4xInt64

publicstaticvar_hasVectorRepresentation:Bool{
@_transparentget{
returnfalse
}
}

publicstaticvarscalarCount:Int{
@_transparentget{
return4
}
}

publicvar_vector:_Vector

public subscript(index:Int)->Scalar{
@_transparentget{
returnInt64(Builtin.extractelement_Vec4xInt64_Int32(
 _vector,
Int32(truncatingIfNeeded: index)._value
))
}
@_transparentset{
 _vector =Builtin.insertelement_Vec4xInt64_Int64_Int32(
 _vector,
 newValue._value,
Int32(truncatingIfNeeded: index)._value
)
}
}

@_transparent
publicinit(){
 _vector =Builtin.zeroInitializer()
}

@_transparent
publicinit(_vector:_Vector){
self._vector = _vector
}
}
}