1 files changed, 97 insertions, 1 deletions

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 68b0f6b635..61361b6dcc 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1299,6 +1299,66 @@ pub const DeclGen = struct {
                 }
                 return llvm_union_ty.constNamedStruct(&fields, fields.len);
             },
+            .Vector => switch (tv.val.tag()) {
+                .bytes => {
+                    // Note, sentinel is not stored even if the type has a sentinel.
+                    const bytes = tv.val.castTag(.bytes).?.data;
+                    const vector_len = tv.ty.arrayLen();
+                    assert(vector_len == bytes.len or vector_len + 1 == bytes.len);
+
+                    const elem_ty = tv.ty.elemType();
+                    const llvm_elems = try self.gpa.alloc(*const llvm.Value, vector_len);
+                    defer self.gpa.free(llvm_elems);
+                    for (llvm_elems) |*elem, i| {
+                        var byte_payload: Value.Payload.U64 = .{
+                            .base = .{ .tag = .int_u64 },
+                            .data = bytes[i],
+                        };
+
+                        elem.* = try self.genTypedValue(.{
+                            .ty = elem_ty,
+                            .val = Value.initPayload(&byte_payload.base),
+                        });
+                    }
+                    return llvm.constVector(
+                        llvm_elems.ptr,
+                        @intCast(c_uint, llvm_elems.len),
+                    );
+                },
+                .array => {
+                    // Note, sentinel is not stored even if the type has a sentinel.
+                    // The value includes the sentinel in those cases.
+                    const elem_vals = tv.val.castTag(.array).?.data;
+                    const vector_len = tv.ty.arrayLen();
+                    assert(vector_len == elem_vals.len or vector_len + 1 == elem_vals.len);
+                    const elem_ty = tv.ty.elemType();
+                    const llvm_elems = try self.gpa.alloc(*const llvm.Value, vector_len);
+                    defer self.gpa.free(llvm_elems);
+                    for (llvm_elems) |*elem, i| {
+                        elem.* = try self.genTypedValue(.{ .ty = elem_ty, .val = elem_vals[i] });
+                    }
+                    return llvm.constVector(
+                        llvm_elems.ptr,
+                        @intCast(c_uint, llvm_elems.len),
+                    );
+                },
+                .repeated => {
+                    // Note, sentinel is not stored even if the type has a sentinel.
+                    const val = tv.val.castTag(.repeated).?.data;
+                    const elem_ty = tv.ty.elemType();
+                    const len = tv.ty.arrayLen();
+                    const llvm_elems = try self.gpa.alloc(*const llvm.Value, len);
+                    defer self.gpa.free(llvm_elems);
+                    for (llvm_elems) |*elem| {
+                        elem.* = try self.genTypedValue(.{ .ty = elem_ty, .val = val });
+                    }
+                    return llvm.constVector(
+                        llvm_elems.ptr,
+                        @intCast(c_uint, llvm_elems.len),
+                    );
+                },
+                else => unreachable,
+            },
 
             .ComptimeInt => unreachable,
             .ComptimeFloat => unreachable,
@@ -1313,7 +1373,6 @@ pub const DeclGen = struct {
 
             .Frame,
             .AnyFrame,
-            .Vector,
             => return self.todo("implement const of type '{}'", .{tv.ty}),
         }
     }
@@ -2992,6 +3051,43 @@ pub const FuncGen = struct {
                 }
             }
             return array_ptr;
+        } else if (operand_ty.zigTypeTag() == .Array and inst_ty.zigTypeTag() == .Vector) {
+            const target = self.dg.module.getTarget();
+            const elem_ty = operand_ty.childType();
+            const llvm_vector_ty = try self.dg.llvmType(inst_ty);
+            if (!isByRef(operand_ty)) {
+                return self.dg.todo("implement bitcast non-ref array to vector", .{});
+            }
+
+            const bitcast_ok = elem_ty.bitSize(target) == elem_ty.abiSize(target) * 8;
+            if (bitcast_ok) {
+                const llvm_vector_ptr_ty = llvm_vector_ty.pointerType(0);
+                const casted_ptr = self.builder.buildBitCast(operand, llvm_vector_ptr_ty, "");
+                const vector = self.builder.buildLoad(casted_ptr, "");
+                // The array is aligned to the element's alignment, while the vector might have a completely
+                // different alignment. This means we need to enforce the alignment of this load.
+                vector.setAlignment(elem_ty.abiAlignment(target));
+                return vector;
+            } else {
+                // If the ABI size of the element type is not evenly divisible by size in bits;
+                // a simple bitcast will not work, and we fall back to extractelement.
+                const llvm_usize = try self.dg.llvmType(Type.usize);
+                const llvm_u32 = self.context.intType(32);
+                const zero = llvm_usize.constNull();
+                const vector_len = operand_ty.arrayLen();
+                var vector = llvm_vector_ty.getUndef();
+                var i: u64 = 0;
+                while (i < vector_len) : (i += 1) {
+                    const index_usize = llvm_usize.constInt(i, .False);
+                    const index_u32 = llvm_u32.constInt(i, .False);
+                    const indexes: [2]*const llvm.Value = .{ zero, index_usize };
+                    const elem_ptr = self.builder.buildInBoundsGEP(operand, &indexes, indexes.len, "");
+                    const elem = self.builder.buildLoad(elem_ptr, "");
+                    vector = self.builder.buildInsertElement(vector, elem, index_u32, "");
+                }
+
+                return vector;
+            }
         }
 
         return self.builder.buildBitCast(operand, llvm_dest_ty, "");