Commit cb8af1c6d48d5fdb26484a070b8af069c4152049 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-11-05 13:39:56-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-11-05 13:40:57-05:00
log	cb8af1c6d48d5fdb26484a070b8af069c4152049
tree	0c3baee6423b40eda3ba57e9d41041f6c9fbd3b8
parent	a26e9fa7238e972301f761db80434fa0205d1016
parent	9a08de93b64a332af9f581ef15b208e153fa19f0
signature	Commit is signed but in an unrecognized format.

Merge branch 'vector-element-access'

This introduces the concept of vector index being part of a pointer
type. This avoids vectors having well-defined in-memory layout, and
allows vectors of any integer bit width to work the same way.

When a vector is indexed with a scalar, this is vector element access,
which this branch implements. When a vector is indexed with a vector,
this is gather/scatter, which is not implemented in this branch.

closes #3575
closes #3580

8 files changed, 422 insertions(+), 41 deletions(-)

src
test
- compile_errors.zig
- stage1
  - behavior
    vector.zig

src/all_types.hpp+30-1

 @@ -1183,13 +1183,22 @@ struct FnTypeId {
 uint32_t fn_type_id_hash(FnTypeId*);
 bool fn_type_id_eql(FnTypeId *a, FnTypeId *b);
+static const uint32_t VECTOR_INDEX_NONE = UINT32_MAX;
+static const uint32_t VECTOR_INDEX_RUNTIME = UINT32_MAX - 1;
 struct ZigTypePointer {
     ZigType *child_type;
     ZigType *slice_parent;
     PtrLen ptr_len;
     uint32_t explicit_alignment; // 0 means use ABI alignment
     uint32_t bit_offset_in_host;
-    uint32_t host_int_bytes; // size of host integer. 0 means no host integer; this field is aligned
+    // size of host integer. 0 means no host integer; this field is aligned
+    // when vector_index != VECTOR_INDEX_NONE this is the len of the containing vector
+    uint32_t host_int_bytes;
+    uint32_t vector_index; // see the VECTOR_INDEX_* constants
     bool is_const;
     bool is_volatile;
     bool allow_zero;
 @@ -1732,8 +1741,11 @@ struct TypeId {
             ZigType *child_type;
             PtrLen ptr_len;
             uint32_t alignment;
             uint32_t bit_offset_in_host;
             uint32_t host_int_bytes;
+            uint32_t vector_index;
             bool is_const;
             bool is_volatile;
             bool allow_zero;
 @@ -2414,6 +2426,7 @@ enum IrInstructionId {
     IrInstructionIdLoadPtr,
     IrInstructionIdLoadPtrGen,
     IrInstructionIdStorePtr,
+    IrInstructionIdVectorStoreElem,
     IrInstructionIdFieldPtr,
     IrInstructionIdStructFieldPtr,
     IrInstructionIdUnionFieldPtr,
 @@ -2563,6 +2576,7 @@ enum IrInstructionId {
     IrInstructionIdResume,
     IrInstructionIdSpillBegin,
     IrInstructionIdSpillEnd,
+    IrInstructionIdVectorExtractElem,
 };
 struct IrInstruction {
 @@ -2757,6 +2771,14 @@ struct IrInstructionStorePtr {
     IrInstruction *value;
 };
+struct IrInstructionVectorStoreElem {
+    IrInstruction base;
+    IrInstruction *vector_ptr;
+    IrInstruction *index;
+    IrInstruction *value;
+};
 struct IrInstructionFieldPtr {
     IrInstruction base;
 @@ -3890,6 +3912,13 @@ struct IrInstructionSpillEnd {
     IrInstructionSpillBegin *begin;
 };
+struct IrInstructionVectorExtractElem {
+    IrInstruction base;
+    IrInstruction *vector;
+    IrInstruction *index;
+};
 enum ResultLocId {
     ResultLocIdInvalid,
     ResultLocIdNone,

src/analyze.cpp+57-14

 @@ -480,9 +480,10 @@ ZigType *get_fn_frame_type(CodeGen *g, ZigFn *fn) {
     return entry;
 }
-ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_const,
+ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type, bool is_const,
         bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment,
-        uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero)
+        uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero,
+        uint32_t vector_index)
 {
     assert(ptr_len != PtrLenC || allow_zero);
     assert(!type_is_invalid(child_type));
 @@ -494,7 +495,7 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
             byte_alignment = 0;
     }
-    if (host_int_bytes != 0) {
+    if (host_int_bytes != 0 && vector_index == VECTOR_INDEX_NONE) {
         uint32_t child_type_bits = type_size_bits(g, child_type);
         if (host_int_bytes * 8 == child_type_bits) {
             assert(bit_offset_in_host == 0);
 @@ -504,7 +505,9 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
     TypeId type_id = {};
     ZigType **parent_pointer = nullptr;
-    if (host_int_bytes != 0 || is_volatile || byte_alignment != 0 || ptr_len != PtrLenSingle || allow_zero) {
+    if (host_int_bytes != 0 || is_volatile || byte_alignment != 0 || ptr_len != PtrLenSingle ||
+        allow_zero || vector_index != VECTOR_INDEX_NONE)
+    {
         type_id.id = ZigTypeIdPointer;
         type_id.data.pointer.child_type = child_type;
         type_id.data.pointer.is_const = is_const;
 @@ -514,6 +517,7 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
         type_id.data.pointer.host_int_bytes = host_int_bytes;
         type_id.data.pointer.ptr_len = ptr_len;
         type_id.data.pointer.allow_zero = allow_zero;
+        type_id.data.pointer.vector_index = vector_index;
         auto existing_entry = g->type_table.maybe_get(type_id);
         if (existing_entry)
 @@ -540,19 +544,36 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
         allow_zero_str = allow_zero ? "allowzero " : "";
     }
     buf_resize(&entry->name, 0);
-    if (host_int_bytes == 0 && byte_alignment == 0) {
+    if (host_int_bytes == 0 && byte_alignment == 0 && vector_index == VECTOR_INDEX_NONE) {
         buf_appendf(&entry->name, "%s%s%s%s%s",
                 star_str, const_str, volatile_str, allow_zero_str, buf_ptr(&child_type->name));
-    } else if (host_int_bytes == 0) {
+    } else if (host_int_bytes == 0 && vector_index == VECTOR_INDEX_NONE) {
         buf_appendf(&entry->name, "%salign(%" PRIu32 ") %s%s%s%s", star_str, byte_alignment,
                 const_str, volatile_str, allow_zero_str, buf_ptr(&child_type->name));
     } else if (byte_alignment == 0) {
-        buf_appendf(&entry->name, "%salign(:%" PRIu32 ":%" PRIu32 ") %s%s%s%s", star_str,
+        assert(vector_index == VECTOR_INDEX_NONE);
-                bit_offset_in_host, host_int_bytes, const_str, volatile_str, allow_zero_str,
+        buf_appendf(&entry->name, "%salign(:%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
+                star_str,
+                bit_offset_in_host, host_int_bytes,
+                const_str, volatile_str, allow_zero_str,
+                buf_ptr(&child_type->name));
+    } else if (vector_index == VECTOR_INDEX_NONE) {
+        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
+                star_str, byte_alignment,
+                bit_offset_in_host, host_int_bytes,
+                const_str, volatile_str, allow_zero_str,
+                buf_ptr(&child_type->name));
+    } else if (vector_index == VECTOR_INDEX_RUNTIME) {
+        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":?) %s%s%s%s",
+                star_str, byte_alignment,
+                bit_offset_in_host, host_int_bytes,
+                const_str, volatile_str, allow_zero_str,
                 buf_ptr(&child_type->name));
     } else {
-        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ") %s%s%s%s", star_str, byte_alignment,
+        buf_appendf(&entry->name, "%salign(%" PRIu32 ":%" PRIu32 ":%" PRIu32 ":%" PRIu32 ") %s%s%s%s",
-                bit_offset_in_host, host_int_bytes, const_str, volatile_str, allow_zero_str,
+                star_str, byte_alignment,
+                bit_offset_in_host, host_int_bytes, vector_index,
+                const_str, volatile_str, allow_zero_str,
                 buf_ptr(&child_type->name));
     }
 @@ -581,6 +602,7 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
     entry->data.pointer.bit_offset_in_host = bit_offset_in_host;
     entry->data.pointer.host_int_bytes = host_int_bytes;
     entry->data.pointer.allow_zero = allow_zero;
+    entry->data.pointer.vector_index = vector_index;
     if (parent_pointer) {
         *parent_pointer = entry;
 @@ -590,8 +612,17 @@ ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_cons
     return entry;
 }
+ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_const,
+        bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment,
+        uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero)
+{
+    return get_pointer_to_type_extra2(g, child_type, is_const, is_volatile, ptr_len,
+            byte_alignment, bit_offset_in_host, host_int_bytes, allow_zero, VECTOR_INDEX_NONE);
+}
 ZigType *get_pointer_to_type(CodeGen *g, ZigType *child_type, bool is_const) {
-    return get_pointer_to_type_extra(g, child_type, is_const, false, PtrLenSingle, 0, 0, 0, false);
+    return get_pointer_to_type_extra2(g, child_type, is_const, false, PtrLenSingle, 0, 0, 0, false,
+            VECTOR_INDEX_NONE);
 }
 ZigType *get_optional_type(CodeGen *g, ZigType *child_type) {
 @@ -6910,6 +6941,7 @@ uint32_t type_id_hash(TypeId x) {
                 (x.data.pointer.allow_zero ? (uint32_t)3324284834 : (uint32_t)3584904923) +
                 (((uint32_t)x.data.pointer.alignment) ^ (uint32_t)0x777fbe0e) +
                 (((uint32_t)x.data.pointer.bit_offset_in_host) ^ (uint32_t)2639019452) +
+                (((uint32_t)x.data.pointer.vector_index) ^ (uint32_t)0x19199716) +
                 (((uint32_t)x.data.pointer.host_int_bytes) ^ (uint32_t)529908881);
         case ZigTypeIdArray:
             return hash_ptr(x.data.array.child_type) +
 @@ -6962,6 +6994,7 @@ bool type_id_eql(TypeId a, TypeId b) {
                 a.data.pointer.allow_zero == b.data.pointer.allow_zero &&
                 a.data.pointer.alignment == b.data.pointer.alignment &&
                 a.data.pointer.bit_offset_in_host == b.data.pointer.bit_offset_in_host &&
+                a.data.pointer.vector_index == b.data.pointer.vector_index &&
                 a.data.pointer.host_int_bytes == b.data.pointer.host_int_bytes;
         case ZigTypeIdArray:
             return a.data.array.child_type == b.data.array.child_type &&
 @@ -8266,11 +8299,21 @@ static void resolve_llvm_types_pointer(CodeGen *g, ZigType *type, ResolveStatus
     if (type->data.pointer.is_const || type->data.pointer.is_volatile ||
         type->data.pointer.explicit_alignment != 0 || type->data.pointer.ptr_len != PtrLenSingle ||
-        type->data.pointer.bit_offset_in_host != 0 || type->data.pointer.allow_zero)
+        type->data.pointer.bit_offset_in_host != 0 || type->data.pointer.allow_zero ||
+        type->data.pointer.vector_index != VECTOR_INDEX_NONE)
     {
         assertNoError(type_resolve(g, elem_type, ResolveStatusLLVMFwdDecl));
-        ZigType *peer_type = get_pointer_to_type_extra(g, elem_type, false, false,
+        ZigType *peer_type;
-                PtrLenSingle, 0, 0, type->data.pointer.host_int_bytes, false);
+        if (type->data.pointer.vector_index == VECTOR_INDEX_NONE) {
+            peer_type = get_pointer_to_type_extra2(g, elem_type, false, false,
+                PtrLenSingle, 0, 0, type->data.pointer.host_int_bytes, false,
+                VECTOR_INDEX_NONE);
+        } else {
+            uint32_t host_vec_len = type->data.pointer.host_int_bytes;
+            ZigType *host_vec_type = get_vector_type(g, host_vec_len, elem_type);
+            peer_type = get_pointer_to_type_extra2(g, host_vec_type, false, false,
+                PtrLenSingle, 0, 0, 0, false, VECTOR_INDEX_NONE);
+        }
         type->llvm_type = get_llvm_type(g, peer_type);
         type->llvm_di_type = get_llvm_di_type(g, peer_type);
         assertNoError(type_resolve(g, elem_type, wanted_resolve_status));

src/analyze.hpp+6-2

 @@ -17,10 +17,14 @@ ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, const AstNode *node,
 ZigType *new_type_table_entry(ZigTypeId id);
 ZigType *get_fn_frame_type(CodeGen *g, ZigFn *fn);
 ZigType *get_pointer_to_type(CodeGen *g, ZigType *child_type, bool is_const);
-ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_const,
+ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type,
-        bool is_volatile, PtrLen ptr_len,
+        bool is_const, bool is_volatile, PtrLen ptr_len,
         uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count,
         bool allow_zero);
+ZigType *get_pointer_to_type_extra2(CodeGen *g, ZigType *child_type,
+        bool is_const, bool is_volatile, PtrLen ptr_len,
+        uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count,
+        bool allow_zero, uint32_t vector_index);
 uint64_t type_size(CodeGen *g, ZigType *type_entry);
 uint64_t type_size_bits(CodeGen *g, ZigType *type_entry);
 ZigType *get_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);

src/codegen.cpp+68-14

 @@ -838,6 +838,11 @@ static LLVMValueRef get_handle_value(CodeGen *g, LLVMValueRef ptr, ZigType *type
     }
 }
+static void ir_assert(bool ok, IrInstruction *source_instruction) {
+    if (ok) return;
+    src_assert(ok, source_instruction->source_node);
+}
 static bool ir_want_fast_math(CodeGen *g, IrInstruction *instruction) {
     // TODO memoize
     Scope *scope = instruction->scope;
 @@ -1635,6 +1640,17 @@ static void gen_assign_raw(CodeGen *g, LLVMValueRef ptr, ZigType *ptr_type,
         return;
     }
+    assert(ptr_type->data.pointer.vector_index != VECTOR_INDEX_RUNTIME);
+    if (ptr_type->data.pointer.vector_index != VECTOR_INDEX_NONE) {
+        LLVMValueRef index_val = LLVMConstInt(LLVMInt32Type(),
+                ptr_type->data.pointer.vector_index, false);
+        LLVMValueRef loaded_vector = gen_load(g, ptr, ptr_type, "");
+        LLVMValueRef new_vector = LLVMBuildInsertElement(g->builder, loaded_vector, value,
+                index_val, "");
+        gen_store(g, new_vector, ptr, ptr_type);
+        return;
+    }
     uint32_t host_int_bytes = ptr_type->data.pointer.host_int_bytes;
     if (host_int_bytes == 0) {
         gen_store(g, value, ptr, ptr_type);
 @@ -1695,11 +1711,11 @@ static LLVMValueRef ir_llvm_value(CodeGen *g, IrInstruction *instruction) {
         }
         if (instruction->spill != nullptr) {
             ZigType *ptr_type = instruction->spill->value.type;
-            src_assert(ptr_type->id == ZigTypeIdPointer, instruction->source_node);
+            ir_assert(ptr_type->id == ZigTypeIdPointer, instruction);
             return get_handle_value(g, ir_llvm_value(g, instruction->spill),
                 ptr_type->data.pointer.child_type, instruction->spill->value.type);
         }
-        src_assert(instruction->value.special != ConstValSpecialRuntime, instruction->source_node);
+        ir_assert(instruction->value.special != ConstValSpecialRuntime, instruction);
         assert(instruction->value.type);
         render_const_val(g, &instruction->value, "");
         // we might have to do some pointer casting here due to the way union
 @@ -2428,8 +2444,7 @@ static LLVMValueRef ir_render_return(CodeGen *g, IrExecutable *executable, IrIns
             return nullptr;
         }
         assert(g->cur_ret_ptr);
-        src_assert(instruction->operand->value.special != ConstValSpecialRuntime,
+        ir_assert(instruction->operand->value.special != ConstValSpecialRuntime, &instruction->base);
-                instruction->base.source_node);
         LLVMValueRef value = ir_llvm_value(g, instruction->operand);
         ZigType *return_type = instruction->operand->value.type;
         gen_assign_raw(g, g->cur_ret_ptr, get_pointer_to_type(g, return_type, false), value);
 @@ -3399,7 +3414,9 @@ static LLVMValueRef ir_render_decl_var(CodeGen *g, IrExecutable *executable, IrI
     return nullptr;
 }
-static LLVMValueRef ir_render_load_ptr(CodeGen *g, IrExecutable *executable, IrInstructionLoadPtrGen *instruction) {
+static LLVMValueRef ir_render_load_ptr(CodeGen *g, IrExecutable *executable,
+        IrInstructionLoadPtrGen *instruction)
+{
     ZigType *child_type = instruction->base.value.type;
     if (!type_has_bits(child_type))
         return nullptr;
 @@ -3408,6 +3425,14 @@ static LLVMValueRef ir_render_load_ptr(CodeGen *g, IrExecutable *executable, IrI
     ZigType *ptr_type = instruction->ptr->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
+    ir_assert(ptr_type->data.pointer.vector_index != VECTOR_INDEX_RUNTIME, &instruction->base);
+    if (ptr_type->data.pointer.vector_index != VECTOR_INDEX_NONE) {
+        LLVMValueRef index_val = LLVMConstInt(LLVMInt32Type(),
+                ptr_type->data.pointer.vector_index, false);
+        LLVMValueRef loaded_vector = LLVMBuildLoad(g->builder, ptr, "");
+        return LLVMBuildExtractElement(g->builder, loaded_vector, index_val, "");
+    }
     uint32_t host_int_bytes = ptr_type->data.pointer.host_int_bytes;
     if (host_int_bytes == 0)
         return get_handle_value(g, ptr, child_type, ptr_type);
 @@ -3619,6 +3644,19 @@ static LLVMValueRef ir_render_store_ptr(CodeGen *g, IrExecutable *executable, Ir
     return nullptr;
 }
+static LLVMValueRef ir_render_vector_store_elem(CodeGen *g, IrExecutable *executable,
+        IrInstructionVectorStoreElem *instruction)
+{
+    LLVMValueRef vector_ptr = ir_llvm_value(g, instruction->vector_ptr);
+    LLVMValueRef index = ir_llvm_value(g, instruction->index);
+    LLVMValueRef value = ir_llvm_value(g, instruction->value);
+    LLVMValueRef loaded_vector = gen_load(g, vector_ptr, instruction->vector_ptr->value.type, "");
+    LLVMValueRef modified_vector = LLVMBuildInsertElement(g->builder, loaded_vector, value, index, "");
+    gen_store(g, modified_vector, vector_ptr, instruction->vector_ptr->value.type);
+    return nullptr;
+}
 static LLVMValueRef ir_render_var_ptr(CodeGen *g, IrExecutable *executable, IrInstructionVarPtr *instruction) {
     if (instruction->base.value.special != ConstValSpecialRuntime)
         return ir_llvm_value(g, &instruction->base);
 @@ -3636,7 +3674,7 @@ static LLVMValueRef ir_render_return_ptr(CodeGen *g, IrExecutable *executable,
 {
     if (!type_has_bits(instruction->base.value.type))
         return nullptr;
-    src_assert(g->cur_ret_ptr != nullptr, instruction->base.source_node);
+    ir_assert(g->cur_ret_ptr != nullptr, &instruction->base);
     return g->cur_ret_ptr;
 }
 @@ -3645,7 +3683,6 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
     ZigType *array_ptr_type = instruction->array_ptr->value.type;
     assert(array_ptr_type->id == ZigTypeIdPointer);
     ZigType *array_type = array_ptr_type->data.pointer.child_type;
-    LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
     LLVMValueRef subscript_value = ir_llvm_value(g, instruction->elem_index);
     assert(subscript_value);
 @@ -3657,6 +3694,7 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
     if (array_type->id == ZigTypeIdArray ||
         (array_type->id == ZigTypeIdPointer && array_type->data.pointer.ptr_len == PtrLenSingle))
     {
+        LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
         if (array_type->id == ZigTypeIdPointer) {
             assert(array_type->data.pointer.child_type->id == ZigTypeIdArray);
             array_type = array_type->data.pointer.child_type;
 @@ -3696,12 +3734,14 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
         };
         return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 2, "");
     } else if (array_type->id == ZigTypeIdPointer) {
+        LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
         assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
         LLVMValueRef indices[] = {
             subscript_value
         };
         return LLVMBuildInBoundsGEP(g->builder, array_ptr, indices, 1, "");
     } else if (array_type->id == ZigTypeIdStruct) {
+        LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
         assert(array_type->data.structure.is_slice);
         ZigType *ptr_type = instruction->base.value.type;
 @@ -3729,6 +3769,8 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
         LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, (unsigned)ptr_index, "");
         LLVMValueRef ptr = gen_load_untyped(g, ptr_ptr, 0, false, "");
         return LLVMBuildInBoundsGEP(g->builder, ptr, &subscript_value, 1, "");
+    } else if (array_type->id == ZigTypeIdVector) {
+        return array_ptr_ptr;
     } else {
         zig_unreachable();
     }
 @@ -3917,9 +3959,9 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
             if (instruction->modifier == CallModifierAsync) {
                 frame_result_loc = result_loc;
             } else {
-                src_assert(instruction->frame_result_loc != nullptr, instruction->base.source_node);
+                ir_assert(instruction->frame_result_loc != nullptr, &instruction->base);
                 frame_result_loc_uncasted = ir_llvm_value(g, instruction->frame_result_loc);
-                src_assert(instruction->fn_entry != nullptr, instruction->base.source_node);
+                ir_assert(instruction->fn_entry != nullptr, &instruction->base);
                 frame_result_loc = LLVMBuildBitCast(g->builder, frame_result_loc_uncasted,
                         LLVMPointerType(get_llvm_type(g, instruction->fn_entry->frame_type), 0), "");
             }
 @@ -4271,10 +4313,10 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, IrExecutable *executa
     if ((err = type_resolve(g, struct_type, ResolveStatusLLVMFull)))
         codegen_report_errors_and_exit(g);
-    src_assert(field->gen_index != SIZE_MAX, instruction->base.source_node);
+    ir_assert(field->gen_index != SIZE_MAX, &instruction->base);
     LLVMValueRef field_ptr_val = LLVMBuildStructGEP(g->builder, struct_ptr, (unsigned)field->gen_index, "");
     ZigType *res_type = instruction->base.value.type;
-    src_assert(res_type->id == ZigTypeIdPointer, instruction->base.source_node);
+    ir_assert(res_type->id == ZigTypeIdPointer, &instruction->base);
     if (res_type->data.pointer.host_int_bytes != 0) {
         // We generate packed structs with get_llvm_type_of_n_bytes, which is
         // u8 for 1 byte or [n]u8 for multiple bytes. But the pointer to the type
 @@ -4684,7 +4726,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen *g, IrExecutable *executabl
 static LLVMValueRef ir_render_splat(CodeGen *g, IrExecutable *executable, IrInstructionSplatGen *instruction) {
     ZigType *result_type = instruction->base.value.type;
-    src_assert(result_type->id == ZigTypeIdVector, instruction->base.source_node);
+    ir_assert(result_type->id == ZigTypeIdVector, &instruction->base);
     uint32_t len = result_type->data.vector.len;
     LLVMTypeRef op_llvm_type = LLVMVectorType(get_llvm_type(g, instruction->scalar->value.type), 1);
     LLVMTypeRef mask_llvm_type = LLVMVectorType(LLVMInt32Type(), len);
 @@ -5039,8 +5081,8 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutable *executable, IrIn
     }
     LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
-    src_assert(result_loc != nullptr, instruction->base.source_node);
+    ir_assert(result_loc != nullptr, &instruction->base);
-    src_assert(type_has_bits(child_type), instruction->base.source_node);
+    ir_assert(type_has_bits(child_type), &instruction->base);
     LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
     LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, result_loc, maybe_child_index, "");
 @@ -5973,6 +6015,14 @@ static LLVMValueRef ir_render_spill_end(CodeGen *g, IrExecutable *executable, Ir
     zig_unreachable();
 }
+static LLVMValueRef ir_render_vector_extract_elem(CodeGen *g, IrExecutable *executable,
+        IrInstructionVectorExtractElem *instruction)
+{
+    LLVMValueRef vector = ir_llvm_value(g, instruction->vector);
+    LLVMValueRef index = ir_llvm_value(g, instruction->index);
+    return LLVMBuildExtractElement(g->builder, vector, index, "");
+}
 static void set_debug_location(CodeGen *g, IrInstruction *instruction) {
     AstNode *source_node = instruction->source_node;
     Scope *scope = instruction->scope;
 @@ -6093,6 +6143,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_load_ptr(g, executable, (IrInstructionLoadPtrGen *)instruction);
         case IrInstructionIdStorePtr:
             return ir_render_store_ptr(g, executable, (IrInstructionStorePtr *)instruction);
+        case IrInstructionIdVectorStoreElem:
+            return ir_render_vector_store_elem(g, executable, (IrInstructionVectorStoreElem *)instruction);
         case IrInstructionIdVarPtr:
             return ir_render_var_ptr(g, executable, (IrInstructionVarPtr *)instruction);
         case IrInstructionIdReturnPtr:
 @@ -6233,6 +6285,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_shuffle_vector(g, executable, (IrInstructionShuffleVector *) instruction);
         case IrInstructionIdSplatGen:
             return ir_render_splat(g, executable, (IrInstructionSplatGen *) instruction);
+        case IrInstructionIdVectorExtractElem:
+            return ir_render_vector_extract_elem(g, executable, (IrInstructionVectorExtractElem *) instruction);
     }
     zig_unreachable();
 }

src/ir.cpp+111-10

...	@@ -491,6 +491,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionStorePtr *) {	...	@@ -491,6 +491,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionStorePtr *) {
491	return IrInstructionIdStorePtr;	491	return IrInstructionIdStorePtr;
492	}	492	}
493		493
		494	static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorStoreElem *) {
		495	return IrInstructionIdVectorStoreElem;
		496	}
		497
494	static constexpr IrInstructionId ir_instruction_id(IrInstructionFieldPtr *) {	498	static constexpr IrInstructionId ir_instruction_id(IrInstructionFieldPtr *) {
495	return IrInstructionIdFieldPtr;	499	return IrInstructionIdFieldPtr;
496	}	500	}
...	@@ -1083,6 +1087,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionSpillEnd *) {	...	@@ -1083,6 +1087,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionSpillEnd *) {
1083	return IrInstructionIdSpillEnd;	1087	return IrInstructionIdSpillEnd;
1084	}	1088	}
1085		1089
		1090	static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorExtractElem *) {
		1091	return IrInstructionIdVectorExtractElem;
		1092	}
		1093
1086	template<typename T>	1094	template<typename T>
1087	static T ir_create_instruction(IrBuilder irb, Scope scope, AstNode source_node) {	1095	static T ir_create_instruction(IrBuilder irb, Scope scope, AstNode source_node) {
1088	const char *name = nullptr;	1096	const char *name = nullptr;
...	@@ -1627,6 +1635,23 @@ static IrInstructionStorePtr ir_build_store_ptr(IrBuilder irb, Scope *scope, A	...	@@ -1627,6 +1635,23 @@ static IrInstructionStorePtr ir_build_store_ptr(IrBuilder irb, Scope *scope, A
1627	return instruction;	1635	return instruction;
1628	}	1636	}
1629		1637
		1638	static IrInstruction ir_build_vector_store_elem(IrAnalyze ira, IrInstruction *source_instruction,
		1639	IrInstruction vector_ptr, IrInstruction index, IrInstruction *value)
		1640	{
		1641	IrInstructionVectorStoreElem *inst = ir_build_instruction<IrInstructionVectorStoreElem>(
		1642	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
		1643	inst->base.value.type = ira->codegen->builtin_types.entry_void;
		1644	inst->vector_ptr = vector_ptr;
		1645	inst->index = index;
		1646	inst->value = value;
		1647
		1648	ir_ref_instruction(vector_ptr, ira->new_irb.current_basic_block);
		1649	ir_ref_instruction(index, ira->new_irb.current_basic_block);
		1650	ir_ref_instruction(value, ira->new_irb.current_basic_block);
		1651
		1652	return &inst->base;
		1653	}
		1654
1630	static IrInstruction ir_build_var_decl_src(IrBuilder irb, Scope scope, AstNode source_node,	1655	static IrInstruction ir_build_var_decl_src(IrBuilder irb, Scope scope, AstNode source_node,
1631	ZigVar var, IrInstruction align_value, IrInstruction *ptr)	1656	ZigVar var, IrInstruction align_value, IrInstruction *ptr)
1632	{	1657	{
...	@@ -3419,6 +3444,21 @@ static IrInstruction ir_build_spill_end(IrBuilder irb, Scope scope, AstNode	...	@@ -3419,6 +3444,21 @@ static IrInstruction ir_build_spill_end(IrBuilder irb, Scope scope, AstNode
3419	return &instruction->base;	3444	return &instruction->base;
3420	}	3445	}
3421		3446
		3447	static IrInstruction ir_build_vector_extract_elem(IrAnalyze ira, IrInstruction *source_instruction,
		3448	IrInstruction vector, IrInstruction index)
		3449	{
		3450	IrInstructionVectorExtractElem *instruction = ir_build_instruction<IrInstructionVectorExtractElem>(
		3451	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
		3452	instruction->base.value.type = vector->value.type->data.vector.elem_type;
		3453	instruction->vector = vector;
		3454	instruction->index = index;
		3455
		3456	ir_ref_instruction(vector, ira->new_irb.current_basic_block);
		3457	ir_ref_instruction(index, ira->new_irb.current_basic_block);
		3458
		3459	return &instruction->base;
		3460	}
		3461
3422	static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope outer_scope, size_t results) {	3462	static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope outer_scope, size_t results) {
3423	results[ReturnKindUnconditional] = 0;	3463	results[ReturnKindUnconditional] = 0;
3424	results[ReturnKindError] = 0;	3464	results[ReturnKindError] = 0;
...	@@ -12908,18 +12948,18 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc	...	@@ -12908,18 +12948,18 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
12908	ResultLoc *result_loc)	12948	ResultLoc *result_loc)
12909	{	12949	{
12910	Error err;	12950	Error err;
12911	ZigType *type_entry = ptr->value.type;	12951	ZigType *ptr_type = ptr->value.type;
12912	if (type_is_invalid(type_entry))	12952	if (type_is_invalid(ptr_type))
12913	return ira->codegen->invalid_instruction;	12953	return ira->codegen->invalid_instruction;
12914		12954
12915	if (type_entry->id != ZigTypeIdPointer) {	12955	if (ptr_type->id != ZigTypeIdPointer) {
12916	ir_add_error_node(ira, source_instruction->source_node,	12956	ir_add_error_node(ira, source_instruction->source_node,
12917	buf_sprintf("attempt to dereference non-pointer type '%s'",	12957	buf_sprintf("attempt to dereference non-pointer type '%s'",
12918	buf_ptr(&type_entry->name)));	12958	buf_ptr(&ptr_type->name)));
12919	return ira->codegen->invalid_instruction;	12959	return ira->codegen->invalid_instruction;
12920	}	12960	}
12921		12961
12922	ZigType *child_type = type_entry->data.pointer.child_type;	12962	ZigType *child_type = ptr_type->data.pointer.child_type;
12923	// if the child type has one possible value, the deref is comptime	12963	// if the child type has one possible value, the deref is comptime
12924	switch (type_has_one_possible_value(ira->codegen, child_type)) {	12964	switch (type_has_one_possible_value(ira->codegen, child_type)) {
12925	case OnePossibleValueInvalid:	12965	case OnePossibleValueInvalid:
...	@@ -12949,14 +12989,36 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc	...	@@ -12949,14 +12989,36 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
12949	}	12989	}
12950	}	12990	}
12951	}	12991	}
		12992
12952	// if the instruction is a const ref instruction we can skip it	12993	// if the instruction is a const ref instruction we can skip it
12953	if (ptr->id == IrInstructionIdRef) {	12994	if (ptr->id == IrInstructionIdRef) {
12954	IrInstructionRef ref_inst = reinterpret_cast<IrInstructionRef >(ptr);	12995	IrInstructionRef ref_inst = reinterpret_cast<IrInstructionRef >(ptr);
12955	return ref_inst->value;	12996	return ref_inst->value;
12956	}	12997	}
12957		12998
		12999	// If the instruction is a element pointer instruction to a vector, we emit
		13000	// vector element extract instruction rather than load pointer. If the
		13001	// pointer type has non-VECTOR_INDEX_RUNTIME value, it would have been
		13002	// possible to implement this in the codegen for IrInstructionLoadPtrGen.
		13003	// However if it has VECTOR_INDEX_RUNTIME then we must emit a compile error
		13004	// if the vector index cannot be determined right here, right now, because
		13005	// the type information does not contain enough information to actually
		13006	// perform a dereference.
		13007	if (ptr_type->data.pointer.vector_index == VECTOR_INDEX_RUNTIME) {
		13008	if (ptr->id == IrInstructionIdElemPtr) {
		13009	IrInstructionElemPtr elem_ptr = (IrInstructionElemPtr )ptr;
		13010	IrInstruction *vector_loaded = ir_get_deref(ira, elem_ptr->array_ptr,
		13011	elem_ptr->array_ptr, nullptr);
		13012	IrInstruction *elem_index = elem_ptr->elem_index;
		13013	return ir_build_vector_extract_elem(ira, source_instruction, vector_loaded, elem_index);
		13014	}
		13015	ir_add_error(ira, ptr,
		13016	buf_sprintf("unable to determine vector element index of type '%s'", buf_ptr(&ptr_type->name)));
		13017	return ira->codegen->invalid_instruction;
		13018	}
		13019
12958	IrInstruction *result_loc_inst;	13020	IrInstruction *result_loc_inst;
12959	if (type_entry->data.pointer.host_int_bytes != 0 && handle_is_ptr(child_type)) {	13021	if (ptr_type->data.pointer.host_int_bytes != 0 && handle_is_ptr(child_type)) {
12960	if (result_loc == nullptr) result_loc = no_result_loc();	13022	if (result_loc == nullptr) result_loc = no_result_loc();
12961	result_loc_inst = ir_resolve_result(ira, source_instruction, result_loc, child_type, nullptr,	13023	result_loc_inst = ir_resolve_result(ira, source_instruction, result_loc, child_type, nullptr,
12962	true, false, true);	13024	true, false, true);
...	@@ -16085,6 +16147,24 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source	...	@@ -16085,6 +16147,24 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
16085	mark_comptime_value_escape(ira, source_instr, &value->value);	16147	mark_comptime_value_escape(ira, source_instr, &value->value);
16086	}	16148	}
16087		16149
		16150	// If this is a store to a pointer with a runtime-known vector index,
		16151	// we have to figure out the IrInstruction which represents the index and
		16152	// emit a IrInstructionVectorStoreElem, or emit a compile error
		16153	// explaining why it is impossible for this store to work. Which is that
		16154	// the pointer address is of the vector; without the element index being known
		16155	// we cannot properly perform the insertion.
		16156	if (ptr->value.type->data.pointer.vector_index == VECTOR_INDEX_RUNTIME) {
		16157	if (ptr->id == IrInstructionIdElemPtr) {
		16158	IrInstructionElemPtr elem_ptr = (IrInstructionElemPtr )ptr;
		16159	return ir_build_vector_store_elem(ira, source_instr, elem_ptr->array_ptr,
		16160	elem_ptr->elem_index, value);
		16161	}
		16162	ir_add_error(ira, ptr,
		16163	buf_sprintf("unable to determine vector element index of type '%s'",
		16164	buf_ptr(&ptr->value.type->name)));
		16165	return ira->codegen->invalid_instruction;
		16166	}
		16167
16088	IrInstructionStorePtr *store_ptr = ir_build_store_ptr(&ira->new_irb, source_instr->scope,	16168	IrInstructionStorePtr *store_ptr = ir_build_store_ptr(&ira->new_irb, source_instr->scope,
16089	source_instr->source_node, ptr, value);	16169	source_instr->source_node, ptr, value);
16090	return &store_ptr->base;	16170	return &store_ptr->base;
...	@@ -17488,6 +17568,9 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct	...	@@ -17488,6 +17568,9 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
17488	return ir_get_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,	17568	return ir_get_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,
17489	ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile, 0);	17569	ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile, 0);
17490	}	17570	}
		17571	} else if (array_type->id == ZigTypeIdVector) {
		17572	// This depends on whether the element index is comptime, so it is computed later.
		17573	return_type = nullptr;
17491	} else {	17574	} else {
17492	ir_add_error_node(ira, elem_ptr_instruction->base.source_node,	17575	ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
17493	buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));	17576	buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));
...	@@ -17512,8 +17595,14 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct	...	@@ -17512,8 +17595,14 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
17512	}	17595	}
17513	safety_check_on = false;	17596	safety_check_on = false;
17514	}	17597	}
17515		17598	if (array_type->id == ZigTypeIdVector) {
17516	if (return_type->data.pointer.explicit_alignment != 0) {	17599	ZigType *elem_type = array_type->data.vector.elem_type;
		17600	uint32_t host_vec_len = array_type->data.vector.len;
		17601	return_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
		17602	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
		17603	elem_ptr_instruction->ptr_len,
		17604	get_ptr_align(ira->codegen, ptr_type), 0, host_vec_len, false, (uint32_t)index);
		17605	} else if (return_type->data.pointer.explicit_alignment != 0) {
17517	// figure out the largest alignment possible	17606	// figure out the largest alignment possible
17518		17607
17519	if ((err = type_resolve(ira->codegen, return_type->data.pointer.child_type, ResolveStatusSizeKnown)))	17608	if ((err = type_resolve(ira->codegen, return_type->data.pointer.child_type, ResolveStatusSizeKnown)))
...	@@ -17551,7 +17640,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct	...	@@ -17551,7 +17640,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
17551	return ira->codegen->invalid_instruction;	17640	return ira->codegen->invalid_instruction;
17552		17641
17553	if (array_ptr_val->special == ConstValSpecialUndef && elem_ptr_instruction->init_array_type != nullptr) {	17642	if (array_ptr_val->special == ConstValSpecialUndef && elem_ptr_instruction->init_array_type != nullptr) {
17554	if (array_type->id == ZigTypeIdArray) {	17643	if (array_type->id == ZigTypeIdArray \|\| array_type->id == ZigTypeIdVector) {
17555	array_ptr_val->data.x_array.special = ConstArraySpecialNone;	17644	array_ptr_val->data.x_array.special = ConstArraySpecialNone;
17556	array_ptr_val->data.x_array.data.s_none.elements = create_const_vals(array_type->data.array.len);	17645	array_ptr_val->data.x_array.data.s_none.elements = create_const_vals(array_type->data.array.len);
17557	array_ptr_val->special = ConstValSpecialStatic;	17646	array_ptr_val->special = ConstValSpecialStatic;
...	@@ -17720,7 +17809,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct	...	@@ -17720,7 +17809,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
17720	zig_panic("TODO elem ptr on a slice has a null pointer");	17809	zig_panic("TODO elem ptr on a slice has a null pointer");
17721	}	17810	}
17722	return result;	17811	return result;
17723	} else if (array_type->id == ZigTypeIdArray) {	17812	} else if (array_type->id == ZigTypeIdArray \|\| array_type->id == ZigTypeIdVector) {
17724	IrInstruction *result;	17813	IrInstruction *result;
17725	if (orig_array_ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {	17814	if (orig_array_ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
17726	result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope,	17815	result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope,
...	@@ -17742,6 +17831,14 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct	...	@@ -17742,6 +17831,14 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
17742	}	17831	}
17743	}	17832	}
17744	}	17833	}
		17834	} else if (array_type->id == ZigTypeIdVector) {
		17835	// runtime known element index
		17836	ZigType *elem_type = array_type->data.vector.elem_type;
		17837	uint32_t host_vec_len = array_type->data.vector.len;
		17838	return_type = get_pointer_to_type_extra2(ira->codegen, elem_type,
		17839	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
		17840	elem_ptr_instruction->ptr_len,
		17841	get_ptr_align(ira->codegen, ptr_type), 0, host_vec_len, false, VECTOR_INDEX_RUNTIME);
17745	} else {	17842	} else {
17746	// runtime known element index	17843	// runtime known element index
17747	switch (type_requires_comptime(ira->codegen, return_type)) {	17844	switch (type_requires_comptime(ira->codegen, return_type)) {
...	@@ -26004,6 +26101,8 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction	...	@@ -26004,6 +26101,8 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
26004	case IrInstructionIdFrameSizeGen:	26101	case IrInstructionIdFrameSizeGen:
26005	case IrInstructionIdAwaitGen:	26102	case IrInstructionIdAwaitGen:
26006	case IrInstructionIdSplatGen:	26103	case IrInstructionIdSplatGen:
		26104	case IrInstructionIdVectorExtractElem:
		26105	case IrInstructionIdVectorStoreElem:
26007	zig_unreachable();	26106	zig_unreachable();
26008		26107
26009	case IrInstructionIdReturn:	26108	case IrInstructionIdReturn:
...	@@ -26387,6 +26486,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -26387,6 +26486,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
26387	case IrInstructionIdDeclVarSrc:	26486	case IrInstructionIdDeclVarSrc:
26388	case IrInstructionIdDeclVarGen:	26487	case IrInstructionIdDeclVarGen:
26389	case IrInstructionIdStorePtr:	26488	case IrInstructionIdStorePtr:
		26489	case IrInstructionIdVectorStoreElem:
26390	case IrInstructionIdCallSrc:	26490	case IrInstructionIdCallSrc:
26391	case IrInstructionIdCallGen:	26491	case IrInstructionIdCallGen:
26392	case IrInstructionIdReturn:	26492	case IrInstructionIdReturn:
...	@@ -26539,6 +26639,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -26539,6 +26639,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
26539	case IrInstructionIdAllocaSrc:	26639	case IrInstructionIdAllocaSrc:
26540	case IrInstructionIdAllocaGen:	26640	case IrInstructionIdAllocaGen:
26541	case IrInstructionIdSpillEnd:	26641	case IrInstructionIdSpillEnd:
		26642	case IrInstructionIdVectorExtractElem:
26542	return false;	26643	return false;
26543		26644
26544	case IrInstructionIdAsm:	26645	case IrInstructionIdAsm:

src/ir_print.cpp+27

 @@ -78,6 +78,8 @@ const char* ir_instruction_type_str(IrInstructionId id) {
             return "LoadPtrGen";
         case IrInstructionIdStorePtr:
             return "StorePtr";
+        case IrInstructionIdVectorStoreElem:
+            return "VectorStoreElem";
         case IrInstructionIdFieldPtr:
             return "FieldPtr";
         case IrInstructionIdStructFieldPtr:
 @@ -370,6 +372,8 @@ const char* ir_instruction_type_str(IrInstructionId id) {
             return "SpillBegin";
         case IrInstructionIdSpillEnd:
             return "SpillEnd";
+        case IrInstructionIdVectorExtractElem:
+            return "VectorExtractElem";
     }
     zig_unreachable();
 }
 @@ -788,6 +792,15 @@ static void ir_print_store_ptr(IrPrint *irp, IrInstructionStorePtr *instruction)
     ir_print_other_instruction(irp, instruction->value);
 }
+static void ir_print_vector_store_elem(IrPrint *irp, IrInstructionVectorStoreElem *instruction) {
+    fprintf(irp->f, "vector_ptr=");
+    ir_print_var_instruction(irp, instruction->vector_ptr);
+    fprintf(irp->f, ",index=");
+    ir_print_var_instruction(irp, instruction->index);
+    fprintf(irp->f, ",value=");
+    ir_print_other_instruction(irp, instruction->value);
+}
 static void ir_print_typeof(IrPrint *irp, IrInstructionTypeOf *instruction) {
     fprintf(irp->f, "@typeOf(");
     ir_print_other_instruction(irp, instruction->value);
 @@ -1969,6 +1982,14 @@ static void ir_print_spill_end(IrPrint *irp, IrInstructionSpillEnd *instruction)
     fprintf(irp->f, ")");
 }
+static void ir_print_vector_extract_elem(IrPrint *irp, IrInstructionVectorExtractElem *instruction) {
+    fprintf(irp->f, "@vectorExtractElem(");
+    ir_print_other_instruction(irp, instruction->vector);
+    fprintf(irp->f, ",");
+    ir_print_other_instruction(irp, instruction->index);
+    fprintf(irp->f, ")");
+}
 static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction, bool trailing) {
     ir_print_prefix(irp, instruction, trailing);
     switch (instruction->id) {
 @@ -2037,6 +2058,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction, bool
         case IrInstructionIdStorePtr:
             ir_print_store_ptr(irp, (IrInstructionStorePtr *)instruction);
             break;
+        case IrInstructionIdVectorStoreElem:
+            ir_print_vector_store_elem(irp, (IrInstructionVectorStoreElem *)instruction);
+            break;
         case IrInstructionIdTypeOf:
             ir_print_typeof(irp, (IrInstructionTypeOf *)instruction);
             break;
 @@ -2466,6 +2490,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction, bool
         case IrInstructionIdSpillEnd:
             ir_print_spill_end(irp, (IrInstructionSpillEnd *)instruction);
             break;
+        case IrInstructionIdVectorExtractElem:
+            ir_print_vector_extract_elem(irp, (IrInstructionVectorExtractElem *)instruction);
+            break;
     }
     fprintf(irp->f, "\n");
 }

test/compile_errors.zig+32

...	@@ -24,6 +24,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {	...	@@ -24,6 +24,38 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
24	"tmp.zig:4:20: note: referenced here",	24	"tmp.zig:4:20: note: referenced here",
25	);	25	);
26		26
		27	cases.add(
		28	"store vector pointer with unknown runtime index",
		29	\\export fn entry() void {
		30	\\ var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
		31	\\
		32	\\ var i: u32 = 0;
		33	\\ storev(&v[i], 42);
		34	\\}
		35	\\
		36	\\fn storev(ptr: var, val: i32) void {
		37	\\ ptr.* = val;
		38	\\}
		39	,
		40	"tmp.zig:9:8: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
		41	);
		42
		43	cases.add(
		44	"load vector pointer with unknown runtime index",
		45	\\export fn entry() void {
		46	\\ var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
		47	\\
		48	\\ var i: u32 = 0;
		49	\\ var x = loadv(&v[i]);
		50	\\}
		51	\\
		52	\\fn loadv(ptr: var) i32 {
		53	\\ return ptr.*;
		54	\\}
		55	,
		56	"tmp.zig:9:12: error: unable to determine vector element index of type '*align(16:0:4:?) i32",
		57	);
		58
27	cases.add(	59	cases.add(
28	"using an unknown len ptr type instead of array",	60	"using an unknown len ptr type instead of array",
29	\\const resolutions = [][]const u8{	61	\\const resolutions = [][]const u8{

test/stage1/behavior/vector.zig+91

...	@@ -159,3 +159,94 @@ test "vector @splat" {	...	@@ -159,3 +159,94 @@ test "vector @splat" {
159	S.doTheTest();	159	S.doTheTest();
160	comptime S.doTheTest();	160	comptime S.doTheTest();
161	}	161	}
		162
		163	test "load vector elements via comptime index" {
		164	const S = struct {
		165	fn doTheTest() void {
		166	var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
		167	expect(v[0] == 1);
		168	expect(v[1] == 2);
		169	expect(loadv(&v[2]) == 3);
		170	}
		171	fn loadv(ptr: var) i32 {
		172	return ptr.*;
		173	}
		174	};
		175
		176	S.doTheTest();
		177	comptime S.doTheTest();
		178	}
		179
		180	test "store vector elements via comptime index" {
		181	const S = struct {
		182	fn doTheTest() void {
		183	var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
		184
		185	v[2] = 42;
		186	expect(v[1] == 5);
		187	v[3] = -364;
		188	expect(v[2] == 42);
		189	expect(-364 == v[3]);
		190
		191	storev(&v[0], 100);
		192	expect(v[0] == 100);
		193	}
		194	fn storev(ptr: var, x: i32) void {
		195	ptr.* = x;
		196	}
		197	};
		198
		199	S.doTheTest();
		200	comptime S.doTheTest();
		201	}
		202
		203	test "load vector elements via runtime index" {
		204	const S = struct {
		205	fn doTheTest() void {
		206	var v: @Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
		207	var i: u32 = 0;
		208	expect(v[i] == 1);
		209	i += 1;
		210	expect(v[i] == 2);
		211	i += 1;
		212	expect(v[i] == 3);
		213	}
		214	};
		215
		216	S.doTheTest();
		217	comptime S.doTheTest();
		218	}
		219
		220	test "store vector elements via runtime index" {
		221	const S = struct {
		222	fn doTheTest() void {
		223	var v: @Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
		224	var i: u32 = 2;
		225	v[i] = 1;
		226	expect(v[1] == 5);
		227	expect(v[2] == 1);
		228	i += 1;
		229	v[i] = -364;
		230	expect(-364 == v[3]);
		231	}
		232	};
		233
		234	S.doTheTest();
		235	comptime S.doTheTest();
		236	}
		237
		238	test "initialize vector which is a struct field" {
		239	const Vec4Obj = struct {
		240	data: @Vector(4, f32),
		241	};
		242
		243	const S = struct {
		244	fn doTheTest() void {
		245	var foo = Vec4Obj{
		246	.data = [_]f32{ 1, 2, 3, 4 },
		247	};
		248	}
		249	};
		250	S.doTheTest();
		251	comptime S.doTheTest();
		252	}