value: remove `indexVectorlike`

Vectors can represented in all the same values as arrays
so this was never a valid shortcut.

1 files changed, 305 insertions, 136 deletions

diff --git a/src/value.zig b/src/value.zig
index 96242331f9..2ef18e6198 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -2044,7 +2044,11 @@ pub const Value = extern union {
         if (ty.zigTypeTag() == .Vector) {
             var i: usize = 0;
             while (i < ty.vectorLen()) : (i += 1) {
-                if (!compareScalar(lhs.indexVectorlike(i), op, rhs.indexVectorlike(i), ty.scalarType(), mod)) {
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                if (!compareScalar(lhs_elem, op, rhs_elem, ty.scalarType(), mod)) {
                     return false;
                 }
             }
@@ -2793,27 +2797,6 @@ pub const Value = extern union {
         };
     }
 
-    /// Index into a vector-like `Value`. Asserts `index` is a valid index for `val`.
-    /// Some scalar values are considered vector-like to avoid needing to allocate
-    /// a new `repeated` each time a constant is used.
-    pub fn indexVectorlike(val: Value, index: usize) Value {
-        return switch (val.tag()) {
-            .aggregate => val.castTag(.aggregate).?.data[index],
-
-            .repeated => val.castTag(.repeated).?.data,
-            // These values will implicitly be treated as `repeated`.
-            .zero,
-            .one,
-            .bool_false,
-            .bool_true,
-            .int_i64,
-            .int_u64,
-            => val,
-
-            else => unreachable,
-        };
-    }
-
     /// Asserts the value is a single-item pointer to an array, or an array,
     /// or an unknown-length pointer, and returns the element value at the index.
     pub fn elemValue(val: Value, mod: *Module, arena: Allocator, index: usize) !Value {
@@ -2889,18 +2872,21 @@ pub const Value = extern union {
             // to have only one possible value itself.
             .the_only_possible_value => return val,
 
-            // pointer to integer casted to pointer of array
-            .int_u64, .int_i64 => {
-                assert(index == 0);
-                return val;
-            },
-
             .opt_payload_ptr => return val.castTag(.opt_payload_ptr).?.data.container_ptr.elemValueAdvanced(mod, index, arena, buffer),
             .eu_payload_ptr => return val.castTag(.eu_payload_ptr).?.data.container_ptr.elemValueAdvanced(mod, index, arena, buffer),
 
             .opt_payload => return val.castTag(.opt_payload).?.data.elemValueAdvanced(mod, index, arena, buffer),
             .eu_payload => return val.castTag(.eu_payload).?.data.elemValueAdvanced(mod, index, arena, buffer),
 
+            // These values will implicitly be treated as `repeated`.
+            .zero,
+            .one,
+            .bool_false,
+            .bool_true,
+            .int_i64,
+            .int_u64,
+            => return val,
+
             else => unreachable,
         }
     }
@@ -3172,18 +3158,21 @@ pub const Value = extern union {
         };
     }
 
-    pub fn intToFloat(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, target: Target) !Value {
-        return intToFloatAdvanced(val, arena, int_ty, float_ty, target, null) catch |err| switch (err) {
+    pub fn intToFloat(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, mod: *Module) !Value {
+        return intToFloatAdvanced(val, arena, int_ty, float_ty, mod, null) catch |err| switch (err) {
             error.OutOfMemory => return error.OutOfMemory,
             else => unreachable,
         };
     }
 
-    pub fn intToFloatAdvanced(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, target: Target, opt_sema: ?*Sema) !Value {
+    pub fn intToFloatAdvanced(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, mod: *Module, opt_sema: ?*Sema) !Value {
+        const target = mod.getTarget();
         if (int_ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, int_ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intToFloatScalar(val.indexVectorlike(i), arena, float_ty.scalarType(), target, opt_sema);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try intToFloatScalar(elem_val, arena, float_ty.scalarType(), target, opt_sema);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3289,12 +3278,17 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intAddSatScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intAddSatScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3333,12 +3327,17 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intSubSatScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intSubSatScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3376,13 +3375,18 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !OverflowArithmeticResult {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const overflowed_data = try arena.alloc(Value, ty.vectorLen());
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                const of_math_result = try intMulWithOverflowScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                const of_math_result = try intMulWithOverflowScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, target);
                 overflowed_data[i] = of_math_result.overflowed;
                 scalar.* = of_math_result.wrapped_result;
             }
@@ -3435,16 +3439,20 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try numberMulWrapScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try numberMulWrapScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, mod);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
-        return numberMulWrapScalar(lhs, rhs, ty, arena, target);
+        return numberMulWrapScalar(lhs, rhs, ty, arena, mod);
     }
 
     /// Supports both floats and ints; handles undefined.
@@ -3453,19 +3461,19 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
         if (lhs.isUndef() or rhs.isUndef()) return Value.initTag(.undef);
 
         if (ty.zigTypeTag() == .ComptimeInt) {
-            return intMul(lhs, rhs, ty, arena, target);
+            return intMul(lhs, rhs, ty, arena, mod);
         }
 
         if (ty.isAnyFloat()) {
-            return floatMul(lhs, rhs, ty, arena, target);
+            return floatMul(lhs, rhs, ty, arena, mod);
         }
 
-        const overflow_result = try intMulWithOverflow(lhs, rhs, ty, arena, target);
+        const overflow_result = try intMulWithOverflow(lhs, rhs, ty, arena, mod);
         return overflow_result.wrapped_result;
     }
 
@@ -3475,12 +3483,17 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intMulSatScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intMulSatScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3547,11 +3560,14 @@ pub const Value = extern union {
     }
 
     /// operands must be (vectors of) integers; handles undefined scalars.
-    pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, target: Target) !Value {
+    pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try bitwiseNotScalar(val.indexVectorlike(i), ty.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try bitwiseNotScalar(elem_val, ty.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3583,11 +3599,16 @@ pub const Value = extern union {
     }
 
     /// operands must be (vectors of) integers; handles undefined scalars.
-    pub fn bitwiseAnd(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn bitwiseAnd(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try bitwiseAndScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try bitwiseAndScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3615,37 +3636,46 @@ pub const Value = extern union {
     }
 
     /// operands must be (vectors of) integers; handles undefined scalars.
-    pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, target: Target) !Value {
+    pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, mod: *Module) !Value {
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try bitwiseNandScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try bitwiseNandScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, mod);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
-        return bitwiseNandScalar(lhs, rhs, ty, arena, target);
+        return bitwiseNandScalar(lhs, rhs, ty, arena, mod);
     }
 
     /// operands must be integers; handles undefined.
-    pub fn bitwiseNandScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, target: Target) !Value {
+    pub fn bitwiseNandScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, mod: *Module) !Value {
         if (lhs.isUndef() or rhs.isUndef()) return Value.initTag(.undef);
 
-        const anded = try bitwiseAnd(lhs, rhs, ty, arena, target);
+        const anded = try bitwiseAnd(lhs, rhs, ty, arena, mod);
 
         const all_ones = if (ty.isSignedInt())
             try Value.Tag.int_i64.create(arena, -1)
         else
-            try ty.maxInt(arena, target);
+            try ty.maxInt(arena, mod.getTarget());
 
-        return bitwiseXor(anded, all_ones, ty, arena, target);
+        return bitwiseXor(anded, all_ones, ty, arena, mod);
     }
 
     /// operands must be (vectors of) integers; handles undefined scalars.
-    pub fn bitwiseOr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn bitwiseOr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try bitwiseOrScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try bitwiseOrScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3672,11 +3702,16 @@ pub const Value = extern union {
     }
 
     /// operands must be (vectors of) integers; handles undefined scalars.
-    pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try bitwiseXorScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try bitwiseXorScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3703,11 +3738,16 @@ pub const Value = extern union {
         return fromBigInt(arena, result_bigint.toConst());
     }
 
-    pub fn intDiv(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn intDiv(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intDivScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intDivScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3739,11 +3779,16 @@ pub const Value = extern union {
         return fromBigInt(allocator, result_q.toConst());
     }
 
-    pub fn intDivFloor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn intDivFloor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intDivFloorScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intDivFloorScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3775,11 +3820,16 @@ pub const Value = extern union {
         return fromBigInt(allocator, result_q.toConst());
     }
 
-    pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intModScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intModScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3846,11 +3896,16 @@ pub const Value = extern union {
         };
     }
 
-    pub fn floatRem(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, target: Target) !Value {
+    pub fn floatRem(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatRemScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatRemScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3888,11 +3943,16 @@ pub const Value = extern union {
         }
     }
 
-    pub fn floatMod(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, target: Target) !Value {
+    pub fn floatMod(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatModScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatModScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -3930,11 +3990,16 @@ pub const Value = extern union {
         }
     }
 
-    pub fn intMul(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn intMul(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intMulScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try intMulScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3962,11 +4027,14 @@ pub const Value = extern union {
         return fromBigInt(allocator, result_bigint.toConst());
     }
 
-    pub fn intTrunc(val: Value, ty: Type, allocator: Allocator, signedness: std.builtin.Signedness, bits: u16, target: Target) !Value {
+    pub fn intTrunc(val: Value, ty: Type, allocator: Allocator, signedness: std.builtin.Signedness, bits: u16, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intTruncScalar(val.indexVectorlike(i), allocator, signedness, bits, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try intTruncScalar(elem_val, allocator, signedness, bits, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -3980,12 +4048,17 @@ pub const Value = extern union {
         allocator: Allocator,
         signedness: std.builtin.Signedness,
         bits: Value,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try intTruncScalar(val.indexVectorlike(i), allocator, signedness, @intCast(u16, bits.indexVectorlike(i).toUnsignedInt(target)), target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                var bits_buf: Value.ElemValueBuffer = undefined;
+                const bits_elem = bits.elemValueBuffer(mod, i, &bits_buf);
+                scalar.* = try intTruncScalar(elem_val, allocator, signedness, @intCast(u16, bits_elem.toUnsignedInt(target)), target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -4008,11 +4081,16 @@ pub const Value = extern union {
         return fromBigInt(allocator, result_bigint.toConst());
     }
 
-    pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try shlScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try shlScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -4043,13 +4121,18 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         allocator: Allocator,
-        target: Target,
+        mod: *Module,
     ) !OverflowArithmeticResult {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const overflowed_data = try allocator.alloc(Value, ty.vectorLen());
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                const of_math_result = try shlWithOverflowScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                const of_math_result = try shlWithOverflowScalar(lhs_elem, rhs_elem, ty.scalarType(), allocator, target);
                 overflowed_data[i] = of_math_result.overflowed;
                 scalar.* = of_math_result.wrapped_result;
             }
@@ -4097,12 +4180,17 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try shlSatScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try shlSatScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4141,16 +4229,20 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try shlTruncScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), ty.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try shlTruncScalar(lhs_elem, rhs_elem, ty.scalarType(), arena, mod);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
-        return shlTruncScalar(lhs, rhs, ty, arena, target);
+        return shlTruncScalar(lhs, rhs, ty, arena, mod);
     }
 
     pub fn shlTruncScalar(
@@ -4158,19 +4250,24 @@ pub const Value = extern union {
         rhs: Value,
         ty: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
-        const shifted = try lhs.shl(rhs, ty, arena, target);
-        const int_info = ty.intInfo(target);
-        const truncated = try shifted.intTrunc(ty, arena, int_info.signedness, int_info.bits, target);
+        const shifted = try lhs.shl(rhs, ty, arena, mod);
+        const int_info = ty.intInfo(mod.getTarget());
+        const truncated = try shifted.intTrunc(ty, arena, int_info.signedness, int_info.bits, mod);
         return truncated;
     }
 
-    pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
+    pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try shrScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try shrScalar(lhs_elem, rhs_elem, allocator, target);
             }
             return Value.Tag.aggregate.create(allocator, result_data);
         }
@@ -4212,12 +4309,15 @@ pub const Value = extern union {
         val: Value,
         float_type: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatNegScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try floatNegScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4245,12 +4345,17 @@ pub const Value = extern union {
         rhs: Value,
         float_type: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatDivScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatDivScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4299,12 +4404,17 @@ pub const Value = extern union {
         rhs: Value,
         float_type: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatDivFloorScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatDivFloorScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4353,12 +4463,17 @@ pub const Value = extern union {
         rhs: Value,
         float_type: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatDivTruncScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatDivTruncScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4407,12 +4522,17 @@ pub const Value = extern union {
         rhs: Value,
         float_type: Type,
         arena: Allocator,
-        target: Target,
+        mod: *Module,
     ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floatMulScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var lhs_buf: Value.ElemValueBuffer = undefined;
+                var rhs_buf: Value.ElemValueBuffer = undefined;
+                const lhs_elem = lhs.elemValueBuffer(mod, i, &lhs_buf);
+                const rhs_elem = rhs.elemValueBuffer(mod, i, &rhs_buf);
+                scalar.* = try floatMulScalar(lhs_elem, rhs_elem, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4456,11 +4576,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn sqrt(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn sqrt(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try sqrtScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try sqrtScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4493,11 +4616,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn sin(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn sin(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try sinScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try sinScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4530,11 +4656,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn cos(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn cos(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try cosScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try cosScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4567,11 +4696,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn tan(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn tan(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try tanScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try tanScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4604,11 +4736,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn exp(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn exp(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try expScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try expScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4641,11 +4776,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn exp2(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn exp2(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try exp2Scalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try exp2Scalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4678,11 +4816,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn log(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn log(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try logScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try logScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4715,11 +4856,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn log2(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn log2(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try log2Scalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try log2Scalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4752,11 +4896,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn log10(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn log10(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try log10Scalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try log10Scalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4789,11 +4936,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn fabs(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn fabs(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try fabsScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try fabsScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4826,11 +4976,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn floor(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn floor(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try floorScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try floorScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4863,11 +5016,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn ceil(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn ceil(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try ceilScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try ceilScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4900,11 +5056,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn round(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn round(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try roundScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try roundScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4937,11 +5096,14 @@ pub const Value = extern union {
         }
     }
 
-    pub fn trunc(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
+    pub fn trunc(val: Value, float_type: Type, arena: Allocator, mod: *Module) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
-                scalar.* = try truncScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
+                var buf: Value.ElemValueBuffer = undefined;
+                const elem_val = val.elemValueBuffer(mod, i, &buf);
+                scalar.* = try truncScalar(elem_val, float_type.scalarType(), arena, target);
             }
             return Value.Tag.aggregate.create(arena, result_data);
         }
@@ -4980,16 +5142,23 @@ pub const Value = extern union {
         mulend2: Value,
         addend: Value,
         arena: Allocator,
-        target: Target,
-    ) Allocator.Error!Value {
+        mod: *Module,
+    ) !Value {
+        const target = mod.getTarget();
         if (float_type.zigTypeTag() == .Vector) {
             const result_data = try arena.alloc(Value, float_type.vectorLen());
             for (result_data) |*scalar, i| {
+                var mulend1_buf: Value.ElemValueBuffer = undefined;
+                const mulend1_elem = mulend1.elemValueBuffer(mod, i, &mulend1_buf);
+                var mulend2_buf: Value.ElemValueBuffer = undefined;
+                const mulend2_elem = mulend2.elemValueBuffer(mod, i, &mulend2_buf);
+                var addend_buf: Value.ElemValueBuffer = undefined;
+                const addend_elem = addend.elemValueBuffer(mod, i, &addend_buf);
                 scalar.* = try mulAddScalar(
                     float_type.scalarType(),
-                    mulend1.indexVectorlike(i),
-                    mulend2.indexVectorlike(i),
-                    addend.indexVectorlike(i),
+                    mulend1_elem,
+                    mulend2_elem,
+                    addend_elem,
                     arena,
                     target,
                 );