From ee334aea801c71cbcc567b1d19be9c04d911beda Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Mon, 19 Dec 2022 16:13:12 +0200 Subject: value: remove `indexVectorlike` Vectors can represented in all the same values as arrays so this was never a valid shortcut. --- src/value.zig | 441 ++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 305 insertions(+), 136 deletions(-) (limited to 'src/value.zig') 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, ); -- cgit v1.2.3