Commit fbda15632d
Changed files (2)
src
test
behavior
src/Sema.zig
@@ -8957,9 +8957,21 @@ fn intCast(
const wanted_bits = wanted_info.bits;
if (wanted_bits == 0) {
- const zero_inst = try sema.addConstant(sema.typeOf(operand), Value.zero);
- const is_in_range = try block.addBinOp(.cmp_eq, operand, zero_inst);
- try sema.addSafetyCheck(block, is_in_range, .cast_truncated_data);
+ const ok = if (is_vector) ok: {
+ const zeros = try Value.Tag.repeated.create(sema.arena, Value.zero);
+ const zero_inst = try sema.addConstant(sema.typeOf(operand), zeros);
+ const is_in_range = try block.addCmpVector(operand, zero_inst, .eq, try sema.addType(operand_ty));
+ const all_in_range = try block.addInst(.{
+ .tag = .reduce,
+ .data = .{ .reduce = .{ .operand = is_in_range, .operation = .And } },
+ });
+ break :ok all_in_range;
+ } else ok: {
+ const zero_inst = try sema.addConstant(sema.typeOf(operand), Value.zero);
+ const is_in_range = try block.addBinOp(.cmp_lte, operand, zero_inst);
+ break :ok is_in_range;
+ };
+ try sema.addSafetyCheck(block, ok, .cast_truncated_data);
}
}
@@ -12376,6 +12388,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -12439,7 +12453,10 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
}
}
@@ -12532,6 +12549,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -12569,7 +12588,10 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
return sema.failWithUseOfUndef(block, rhs_src);
} else {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
}
}
@@ -12691,6 +12713,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -12730,7 +12754,10 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
}
}
@@ -12803,6 +12830,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -12842,7 +12871,10 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
}
}
@@ -13042,6 +13074,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -13078,7 +13112,10 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
return sema.failWithUseOfUndef(block, lhs_src);
}
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
} else if (lhs_scalar_ty.isSignedInt()) {
return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
@@ -13087,25 +13124,19 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
if (rhs_val.isUndef()) {
return sema.failWithUseOfUndef(block, rhs_src);
}
- if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.failWithDivideByZero(block, rhs_src);
+ switch (try rhs_val.orderAgainstZeroAdvanced(sema.kit(block, src))) {
+ .lt => return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty),
+ .eq => return sema.failWithDivideByZero(block, rhs_src),
+ .gt => {},
}
if (maybe_lhs_val) |lhs_val| {
const rem_result = try sema.intRem(block, resolved_type, lhs_val, lhs_src, rhs_val, rhs_src);
// If this answer could possibly be different by doing `intMod`,
// we must emit a compile error. Otherwise, it's OK.
- if ((try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) != (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) and
+ if ((try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) and
!(try rem_result.compareWithZeroAdvanced(.eq, sema.kit(block, src))))
{
- const bad_src = if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src)))
- lhs_src
- else
- rhs_src;
- return sema.failWithModRemNegative(block, bad_src, lhs_ty, rhs_ty);
- }
- if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) {
- // Negative
- return sema.addConstant(resolved_type, Value.zero);
+ return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
}
return sema.addConstant(resolved_type, rem_result);
}
@@ -13671,6 +13702,8 @@ fn analyzeArithmetic(
.override = &[_]LazySrcLoc{ lhs_src, rhs_src },
});
+ const is_vector = resolved_type.zigTypeTag() == .Vector;
+
const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
@@ -13897,7 +13930,10 @@ fn analyzeArithmetic(
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, lhs_val, .eq, Value.one, resolved_type)) {
return casted_rhs;
@@ -13914,7 +13950,10 @@ fn analyzeArithmetic(
}
}
if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, rhs_val, .eq, Value.one, resolved_type)) {
return casted_lhs;
@@ -13951,7 +13990,10 @@ fn analyzeArithmetic(
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, lhs_val, .eq, Value.one, resolved_type)) {
return casted_rhs;
@@ -13964,7 +14006,10 @@ fn analyzeArithmetic(
return sema.addConstUndef(resolved_type);
}
if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, rhs_val, .eq, Value.one, resolved_type)) {
return casted_lhs;
@@ -13988,7 +14033,10 @@ fn analyzeArithmetic(
if (maybe_lhs_val) |lhs_val| {
if (!lhs_val.isUndef()) {
if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, lhs_val, .eq, Value.one, resolved_type)) {
return casted_rhs;
@@ -14000,7 +14048,10 @@ fn analyzeArithmetic(
return sema.addConstUndef(resolved_type);
}
if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
- return sema.addConstant(resolved_type, Value.zero);
+ const zero_val = if (is_vector) b: {
+ break :b try Value.Tag.repeated.create(sema.arena, Value.zero);
+ } else Value.zero;
+ return sema.addConstant(resolved_type, zero_val);
}
if (try sema.compare(block, src, rhs_val, .eq, Value.one, resolved_type)) {
return casted_lhs;
@@ -31735,6 +31786,8 @@ fn floatToIntScalar(
/// Asserts the value is an integer, and the destination type is ComptimeInt or Int.
/// Vectors are also accepted. Vector results are reduced with AND.
+///
+/// If provided, `vector_index` reports the first element that failed the range check.
fn intFitsInType(
sema: *Sema,
block: *Block,
test/behavior/vector.zig
@@ -1136,11 +1136,6 @@ test "array of vectors is copied" {
}
test "byte vector initialized in inline function" {
- if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
const S = struct {
inline fn boolx4(e0: bool, e1: bool, e2: bool, e3: bool) @Vector(4, bool) {
return .{ e0, e1, e2, e3 };
@@ -1170,3 +1165,69 @@ test "byte vector initialized in inline function" {
try expect(S.all(S.boolx4(true, true, true, true)));
}
+
+test "zero divisor" {
+ if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+ const zeros = @Vector(2, f32){ 0.0, 0.0 };
+ const ones = @Vector(2, f32){ 1.0, 1.0 };
+
+ const v1 = zeros / ones;
+ const v2 = @divExact(zeros, ones);
+ const v3 = @divTrunc(zeros, ones);
+ const v4 = @divFloor(zeros, ones);
+
+ _ = v1[0];
+ _ = v2[0];
+ _ = v3[0];
+ _ = v4[0];
+}
+
+test "zero multiplicand" {
+ if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+ const zeros = @Vector(2, u32){ 0.0, 0.0 };
+ var ones = @Vector(2, u32){ 1.0, 1.0 };
+
+ _ = (ones * zeros)[0];
+ _ = (zeros * zeros)[0];
+ _ = (zeros * ones)[0];
+
+ _ = (ones *| zeros)[0];
+ _ = (zeros *| zeros)[0];
+ _ = (zeros *| ones)[0];
+
+ _ = (ones *% zeros)[0];
+ _ = (zeros *% zeros)[0];
+ _ = (zeros *% ones)[0];
+}
+
+test "@intCast to u0" {
+ if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+ var zeros = @Vector(2, u32){ 0, 0 };
+ const casted = @intCast(@Vector(2, u0), zeros);
+
+ _ = casted[0];
+}
+
+test "modRem with zero divisor" {
+ comptime {
+ var zeros = @Vector(2, u32){ 0, 0 };
+ const ones = @Vector(2, u32){ 1, 1 };
+
+ zeros %= ones;
+ _ = zeros[0];
+ }
+}