Fixed vector pointer selectors

Sources/Core/IRGenerator.swift

@@ -1337,16 +1337,23 @@ extension IRGenerator {
         case .staticLength(let length):
             return i64.constant(length)
         case .scalar(let index):
-            let vector = emit(expr: sel.rec, returnAddress: returnAddress)
+            var vector = emit(expr: sel.rec, returnAddress: returnAddress)
+            for _ in 0 ..< sel.levelsOfIndirection {
+                vector = b.buildLoad(vector)
+            }
 
             if returnAddress {
                 return b.buildGEP(vector, indices: [i64.constant(0), i64.constant(index)])
             }
 
             return b.buildExtractElement(vector: vector, index: index)
         case .swizzle(let indices):
-            let vector = emit(expr: sel.rec)
-            let recType = canonicalize(sel.rec.type)
+            var vector = emit(expr: sel.rec)
+            for _ in 0 ..< sel.levelsOfIndirection {
+                vector = b.buildLoad(vector)
+            }
+
+            let recType = canonicalize(findConcreteType(sel.rec.type))
             let maskType = canonicalize(sel.type)
             var shuffleMask = maskType.undef()
             for (i, index) in indices.enumerated() {

Sources/Core/Type.swift

@@ -103,6 +103,15 @@ func findPolymorphic(_ type: Type) -> ty.Polymorphic? {
     }
 }
 
+/// Unwraps a pointer (or nested pointers) until it finds a concrete type.
+func findConcreteType(_ type: Type) -> Type {
+    guard let ptr = type as? ty.Pointer else {
+        return type
+    }
+
+    return findConcreteType(ptr.pointeeType)
+}
+
 /// Recursively searches polyType for a ty.Polymorphic to pair
 ///  with a matching argType. If found the ty.Polymorphic has
 ///  its specialization.val set for future use.