Add Vector constant values and constant shuffling

Author: CodaFi

Sources/LLVM/VectorType.swift

@@ -22,6 +22,23 @@ public struct VectorType: IRType {
     self.count = count
   }
 
+  /// Creates a constant value of this vector type initialized with the given
+  /// list of values.
+  ///
+  /// - precondition: values.count == vector.count
+  /// - parameter values: A list of values of elements of this vector.
+  ///
+  /// - returns: A value representing a constant value of this vector type.
+  public func constant(_ values: [IRValue]) -> Constant<Vector> {
+    assert(numericCast(values.count) == LLVMGetVectorSize(asLLVM()),
+           "The number of values must match the number of elements in the vector")
+    var vals = values.map { $0.asLLVM() as Optional }
+    return vals.withUnsafeMutableBufferPointer { buf in
+      return Constant(llvm: LLVMConstVector(buf.baseAddress,
+                                            UInt32(buf.count)))
+    }
+  }
+
   /// Retrieves the underlying LLVM type object.
   public func asLLVM() -> LLVMTypeRef {
     return LLVMVectorType(elementType.asLLVM(), UInt32(count))

Tests/LLVMTests/ConstantSpec.swift

@@ -138,6 +138,62 @@ class ConstantSpec : XCTestCase {
       // STRUCTCONSTGETELEMENT-NEXT: }
       module.dump()
     })
+
+    XCTAssert(fileCheckOutput(of: .stderr, withPrefixes: ["VECTORCONSTSHUFFLE-IDENTITY"]) {
+      // VECTORCONSTSHUFFLE-IDENTITY: ; ModuleID = '[[ModuleName:ConstantTest]]'
+      // VECTORCONSTSHUFFLE-IDENTITY-NEXT: source_filename = "[[ModuleName]]"
+      let module = Module(name: "ConstantTest")
+      let builder = IRBuilder(module: module)
+
+      let vecTy = VectorType(elementType: IntType.int32, count: 4)
+      // VECTORCONSTSHUFFLE-IDENTITY: define <4 x i32> @main() {
+      let main = builder.addFunction("main",
+                                     type: FunctionType(argTypes: [],
+                                                        returnType: vecTy))
+
+      let vec1 = vecTy.constant([ 1, 2, 3, 4 ] as [Int32])
+      let mask = vecTy.constant([ 0, 1, 2, 3 ] as [Int32])
+
+      // VECTORCONSTSHUFFLE-IDENTITY-NEXT: entry:
+      let entry = main.appendBasicBlock(named: "entry")
+      builder.positionAtEnd(of: entry)
+
+      let firstElement = Constant<Vector>.buildShuffleVector(vec1, and: .undef(vecTy), mask: mask)
+
+      // VECTORCONSTSHUFFLE-IDENTITY-NEXT: ret <4 x i32> <i32 1, i32 2, i32 3, i32 4>
+      builder.buildRet(firstElement)
+      // VECTORCONSTSHUFFLE-IDENTITY-NEXT: }
+      module.dump()
+    })
+
+    XCTAssert(fileCheckOutput(of: .stderr, withPrefixes: ["VECTORCONSTSHUFFLE"]) {
+      // VECTORCONSTSHUFFLE: ; ModuleID = '[[ModuleName:ConstantTest]]'
+      // VECTORCONSTSHUFFLE-NEXT: source_filename = "[[ModuleName]]"
+      let module = Module(name: "ConstantTest")
+      let builder = IRBuilder(module: module)
+
+      let maskTy = VectorType(elementType: IntType.int32, count: 8)
+      // VECTORCONSTSHUFFLE: define <8 x i32> @main() {
+      let main = builder.addFunction("main",
+                                     type: FunctionType(argTypes: [],
+                                                        returnType: maskTy))
+
+      let vecTy = VectorType(elementType: IntType.int32, count: 4)
+      let vec1 = vecTy.constant([ 1, 2, 3, 4 ] as [Int32])
+      let vec2 = vecTy.constant([ 5, 6, 7, 8 ] as [Int32])
+      let mask = maskTy.constant([ 1, 3, 5, 7, 0, 2, 4, 6 ] as [Int32])
+
+      // VECTORCONSTSHUFFLE-NEXT: entry:
+      let entry = main.appendBasicBlock(named: "entry")
+      builder.positionAtEnd(of: entry)
+
+      let firstElement = Constant<Vector>.buildShuffleVector(vec1, and: vec2, mask: mask)
+
+      // VECTORCONSTSHUFFLE-NEXT: ret <8 x i32> <i32 2, i32 4, i32 6, i32 8, i32 1, i32 3, i32 5, i32 7>
+      builder.buildRet(firstElement)
+      // VECTORCONSTSHUFFLE-NEXT: }
+      module.dump()
+    })
   }
 
   #if !os(macOS)

Tests/LLVMTests/IRBuilderSpec.swift

@@ -38,6 +38,12 @@ class IRBuilderSpec : XCTestCase {
       var g2 = builder.addGlobal("b", type: IntType.int32)
       g2.initializer = Int32(1)
 
+      // IRBUILDERARITH-NEXT: @vec1 = global <8 x i64> <i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1, i64 1>
+      // IRBUILDERARITH-NEXT: @vec2 = global <8 x i64> <i64 2, i64 2, i64 2, i64 2, i64 2, i64 2, i64 2, i64 2>
+      let vecTy = VectorType(elementType: IntType.int32, count: 8)
+      let gVec1 = builder.addGlobal("vec1", initializer: vecTy.constant([ 1, 1, 1, 1, 1, 1, 1, 1 ]))
+      let gVec2 = builder.addGlobal("vec2", initializer: vecTy.constant([ 2, 2, 2, 2, 2, 2, 2, 2 ]))
+
       // IRBUILDERARITH: define void @main() {
       let main = builder.addFunction("main",
                                      type: FunctionType(argTypes: [],
@@ -51,6 +57,12 @@ class IRBuilderSpec : XCTestCase {
       // IRBUILDERARITH-NEXT: [[B_LOAD:%[0-9]+]] = load i32, i32* @b
       let vg2 = builder.buildLoad(g2)
 
+      // IRBUILDERARITH-NEXT: [[VEC1_LOAD:%[0-9]+]] = load <8 x i64>, <8 x i64>* @vec1
+      let vgVec1 = builder.buildLoad(gVec1)
+
+      // IRBUILDERARITH-NEXT: [[VEC2_LOAD:%[0-9]+]] = load <8 x i64>, <8 x i64>* @vec2
+      let vgVec2 = builder.buildLoad(gVec2)
+
       // IRBUILDERARITH-NEXT: {{%[0-9]+}} = add i32 [[A_LOAD]], [[B_LOAD]]
       _ = builder.buildAdd(vg1, vg2)
       // IRBUILDERARITH-NEXT: {{%[0-9]+}} = sub i32 [[A_LOAD]], [[B_LOAD]]
@@ -76,6 +88,17 @@ class IRBuilderSpec : XCTestCase {
       // IRBUILDERARITH-NEXT: {{%[0-9]+}} = mul nuw i32 [[A_LOAD]], [[B_LOAD]]
       _ = builder.buildMul(vg1, vg2, overflowBehavior: .noUnsignedWrap)
 
+      // IRBUILDERARITH-NEXT: {{%[0-9]+}} = add <8 x i64> [[VEC1_LOAD]], [[VEC2_LOAD]]
+      _ = builder.buildAdd(vgVec1, vgVec2)
+      // IRBUILDERARITH-NEXT: {{%[0-9]+}} = sub <8 x i64> [[VEC1_LOAD]], [[VEC2_LOAD]]
+      _ = builder.buildSub(vgVec1, vgVec2)
+      // IRBUILDERARITH-NEXT: {{%[0-9]+}} = mul <8 x i64> [[VEC1_LOAD]], [[VEC2_LOAD]]
+      _ = builder.buildMul(vgVec1, vgVec2)
+      // IRBUILDERARITH-NEXT: {{%[0-9]+}} = sdiv <8 x i64> [[VEC1_LOAD]], [[VEC2_LOAD]]
+      _ = builder.buildDiv(vgVec1, vgVec2, signed: true)
+      // IRBUILDERARITH-NEXT: {{%[0-9]+}} = udiv <8 x i64> [[VEC1_LOAD]], [[VEC2_LOAD]]
+      _ = builder.buildDiv(vgVec1, vgVec2, signed: false)
+
       // IRBUILDERARITH-NEXT: {{%[0-9]+}} = sub i32 0, [[A_LOAD]]
       _ = builder.buildNeg(vg1, overflowBehavior: .default)
       // IRBUILDERARITH-NEXT: {{%[0-9]+}} = sub nuw i32 0, [[A_LOAD]]